from _typeshed import Incomplete
from collections.abc import Generator

class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__: Incomplete

swig_version: Incomplete

def lldb_iter(obj, getsize, getelem) -> Generator[Incomplete]:
    """A generator adaptor to support iteration for lldb container objects."""

INT32_MAX: Incomplete
UINT32_MAX: Incomplete
UINT64_MAX: Incomplete
LLDB_GENERIC_ERROR: Incomplete
LLDB_INVALID_BREAK_ID: Incomplete
LLDB_DEFAULT_BREAK_SIZE: Incomplete
LLDB_INVALID_WATCH_ID: Incomplete
LLDB_WATCH_TYPE_READ: Incomplete
LLDB_WATCH_TYPE_WRITE: Incomplete
LLDB_WATCH_TYPE_MODIFY: Incomplete
LLDB_INVALID_SITE_ID: Incomplete
LLDB_REGNUM_GENERIC_PC: Incomplete
LLDB_REGNUM_GENERIC_SP: Incomplete
LLDB_REGNUM_GENERIC_FP: Incomplete
LLDB_REGNUM_GENERIC_RA: Incomplete
LLDB_REGNUM_GENERIC_FLAGS: Incomplete
LLDB_REGNUM_GENERIC_ARG1: Incomplete
LLDB_REGNUM_GENERIC_ARG2: Incomplete
LLDB_REGNUM_GENERIC_ARG3: Incomplete
LLDB_REGNUM_GENERIC_ARG4: Incomplete
LLDB_REGNUM_GENERIC_ARG5: Incomplete
LLDB_REGNUM_GENERIC_ARG6: Incomplete
LLDB_REGNUM_GENERIC_ARG7: Incomplete
LLDB_REGNUM_GENERIC_ARG8: Incomplete
LLDB_REGNUM_GENERIC_TP: Incomplete
LLDB_INVALID_STOP_ID: Incomplete
LLDB_INVALID_ADDRESS: Incomplete
LLDB_INVALID_INDEX32: Incomplete
LLDB_INVALID_IVAR_OFFSET: Incomplete
LLDB_INVALID_IMAGE_TOKEN: Incomplete
LLDB_INVALID_MODULE_VERSION: Incomplete
LLDB_INVALID_REGNUM: Incomplete
LLDB_INVALID_UID: Incomplete
LLDB_INVALID_PROCESS_ID: Incomplete
LLDB_INVALID_THREAD_ID: Incomplete
LLDB_INVALID_FRAME_ID: Incomplete
LLDB_INVALID_SIGNAL_NUMBER: Incomplete
LLDB_INVALID_OFFSET: Incomplete
LLDB_INVALID_LINE_NUMBER: Incomplete
LLDB_INVALID_COLUMN_NUMBER: Incomplete
LLDB_INVALID_QUEUE_ID: Incomplete
LLDB_INVALID_CPU_ID: Incomplete
LLDB_INVALID_WATCHPOINT_RESOURCE_ID: Incomplete
LLDB_ARCH_DEFAULT: Incomplete
LLDB_ARCH_DEFAULT_32BIT: Incomplete
LLDB_ARCH_DEFAULT_64BIT: Incomplete
LLDB_INVALID_CPUTYPE: Incomplete
LLDB_MAX_NUM_OPTION_SETS: Incomplete
LLDB_OPT_SET_ALL: Incomplete
LLDB_OPT_SET_1: Incomplete
LLDB_OPT_SET_2: Incomplete
LLDB_OPT_SET_3: Incomplete
LLDB_OPT_SET_4: Incomplete
LLDB_OPT_SET_5: Incomplete
LLDB_OPT_SET_6: Incomplete
LLDB_OPT_SET_7: Incomplete
LLDB_OPT_SET_8: Incomplete
LLDB_OPT_SET_9: Incomplete
LLDB_OPT_SET_10: Incomplete
LLDB_OPT_SET_11: Incomplete
LLDB_OPT_SET_12: Incomplete
eStateInvalid: Incomplete
eStateUnloaded: Incomplete
eStateConnected: Incomplete
eStateAttaching: Incomplete
eStateLaunching: Incomplete
eStateStopped: Incomplete
eStateRunning: Incomplete
eStateStepping: Incomplete
eStateCrashed: Incomplete
eStateDetached: Incomplete
eStateExited: Incomplete
eStateSuspended: Incomplete
kLastStateType: Incomplete
eLaunchFlagNone: Incomplete
eLaunchFlagExec: Incomplete
eLaunchFlagDebug: Incomplete
eLaunchFlagStopAtEntry: Incomplete
eLaunchFlagDisableASLR: Incomplete
eLaunchFlagDisableSTDIO: Incomplete
eLaunchFlagLaunchInTTY: Incomplete
eLaunchFlagLaunchInShell: Incomplete
eLaunchFlagLaunchInSeparateProcessGroup: Incomplete
eLaunchFlagDontSetExitStatus: Incomplete
eLaunchFlagDetachOnError: Incomplete
eLaunchFlagShellExpandArguments: Incomplete
eLaunchFlagCloseTTYOnExit: Incomplete
eLaunchFlagInheritTCCFromParent: Incomplete
eOnlyThisThread: Incomplete
eAllThreads: Incomplete
eOnlyDuringStepping: Incomplete
eByteOrderInvalid: Incomplete
eByteOrderBig: Incomplete
eByteOrderPDP: Incomplete
eByteOrderLittle: Incomplete
eEncodingInvalid: Incomplete
eEncodingUint: Incomplete
eEncodingSint: Incomplete
eEncodingIEEE754: Incomplete
eEncodingVector: Incomplete
eFormatDefault: Incomplete
eFormatInvalid: Incomplete
eFormatBoolean: Incomplete
eFormatBinary: Incomplete
eFormatBytes: Incomplete
eFormatBytesWithASCII: Incomplete
eFormatChar: Incomplete
eFormatCharPrintable: Incomplete
eFormatComplex: Incomplete
eFormatComplexFloat: Incomplete
eFormatCString: Incomplete
eFormatDecimal: Incomplete
eFormatEnum: Incomplete
eFormatHex: Incomplete
eFormatHexUppercase: Incomplete
eFormatFloat: Incomplete
eFormatOctal: Incomplete
eFormatOSType: Incomplete
eFormatUnicode16: Incomplete
eFormatUnicode32: Incomplete
eFormatUnsigned: Incomplete
eFormatPointer: Incomplete
eFormatVectorOfChar: Incomplete
eFormatVectorOfSInt8: Incomplete
eFormatVectorOfUInt8: Incomplete
eFormatVectorOfSInt16: Incomplete
eFormatVectorOfUInt16: Incomplete
eFormatVectorOfSInt32: Incomplete
eFormatVectorOfUInt32: Incomplete
eFormatVectorOfSInt64: Incomplete
eFormatVectorOfUInt64: Incomplete
eFormatVectorOfFloat16: Incomplete
eFormatVectorOfFloat32: Incomplete
eFormatVectorOfFloat64: Incomplete
eFormatVectorOfUInt128: Incomplete
eFormatComplexInteger: Incomplete
eFormatCharArray: Incomplete
eFormatAddressInfo: Incomplete
eFormatHexFloat: Incomplete
eFormatInstruction: Incomplete
eFormatVoid: Incomplete
eFormatUnicode8: Incomplete
kNumFormats: Incomplete
eDescriptionLevelBrief: Incomplete
eDescriptionLevelFull: Incomplete
eDescriptionLevelVerbose: Incomplete
eDescriptionLevelInitial: Incomplete
kNumDescriptionLevels: Incomplete
eScriptLanguageNone: Incomplete
eScriptLanguagePython: Incomplete
eScriptLanguageLua: Incomplete
eScriptLanguageUnknown: Incomplete
eScriptLanguageDefault: Incomplete
eRegisterKindEHFrame: Incomplete
eRegisterKindDWARF: Incomplete
eRegisterKindGeneric: Incomplete
eRegisterKindProcessPlugin: Incomplete
eRegisterKindLLDB: Incomplete
kNumRegisterKinds: Incomplete
eStopReasonInvalid: Incomplete
eStopReasonNone: Incomplete
eStopReasonTrace: Incomplete
eStopReasonBreakpoint: Incomplete
eStopReasonWatchpoint: Incomplete
eStopReasonSignal: Incomplete
eStopReasonException: Incomplete
eStopReasonExec: Incomplete
eStopReasonPlanComplete: Incomplete
eStopReasonThreadExiting: Incomplete
eStopReasonInstrumentation: Incomplete
eStopReasonProcessorTrace: Incomplete
eStopReasonFork: Incomplete
eStopReasonVFork: Incomplete
eStopReasonVForkDone: Incomplete
eReturnStatusInvalid: Incomplete
eReturnStatusSuccessFinishNoResult: Incomplete
eReturnStatusSuccessFinishResult: Incomplete
eReturnStatusSuccessContinuingNoResult: Incomplete
eReturnStatusSuccessContinuingResult: Incomplete
eReturnStatusStarted: Incomplete
eReturnStatusFailed: Incomplete
eReturnStatusQuit: Incomplete
eExpressionCompleted: Incomplete
eExpressionSetupError: Incomplete
eExpressionParseError: Incomplete
eExpressionDiscarded: Incomplete
eExpressionInterrupted: Incomplete
eExpressionHitBreakpoint: Incomplete
eExpressionTimedOut: Incomplete
eExpressionResultUnavailable: Incomplete
eExpressionStoppedForDebug: Incomplete
eExpressionThreadVanished: Incomplete
eSearchDepthInvalid: Incomplete
eSearchDepthTarget: Incomplete
eSearchDepthModule: Incomplete
eSearchDepthCompUnit: Incomplete
eSearchDepthFunction: Incomplete
eSearchDepthBlock: Incomplete
eSearchDepthAddress: Incomplete
kLastSearchDepthKind: Incomplete
eConnectionStatusSuccess: Incomplete
eConnectionStatusEndOfFile: Incomplete
eConnectionStatusError: Incomplete
eConnectionStatusTimedOut: Incomplete
eConnectionStatusNoConnection: Incomplete
eConnectionStatusLostConnection: Incomplete
eConnectionStatusInterrupted: Incomplete
eErrorTypeInvalid: Incomplete
eErrorTypeGeneric: Incomplete
eErrorTypeMachKernel: Incomplete
eErrorTypePOSIX: Incomplete
eErrorTypeExpression: Incomplete
eErrorTypeWin32: Incomplete
eValueTypeInvalid: Incomplete
eValueTypeVariableGlobal: Incomplete
eValueTypeVariableStatic: Incomplete
eValueTypeVariableArgument: Incomplete
eValueTypeVariableLocal: Incomplete
eValueTypeRegister: Incomplete
eValueTypeRegisterSet: Incomplete
eValueTypeConstResult: Incomplete
eValueTypeVariableThreadLocal: Incomplete
eValueTypeVTable: Incomplete
eValueTypeVTableEntry: Incomplete
eInputReaderGranularityInvalid: Incomplete
eInputReaderGranularityByte: Incomplete
eInputReaderGranularityWord: Incomplete
eInputReaderGranularityLine: Incomplete
eInputReaderGranularityAll: Incomplete
eSymbolContextTarget: Incomplete
eSymbolContextModule: Incomplete
eSymbolContextCompUnit: Incomplete
eSymbolContextFunction: Incomplete
eSymbolContextBlock: Incomplete
eSymbolContextLineEntry: Incomplete
eSymbolContextSymbol: Incomplete
eSymbolContextEverything: Incomplete
eSymbolContextVariable: Incomplete
eSymbolContextLastItem: Incomplete
ePermissionsWritable: Incomplete
ePermissionsReadable: Incomplete
ePermissionsExecutable: Incomplete
eInputReaderActivate: Incomplete
eInputReaderAsynchronousOutputWritten: Incomplete
eInputReaderReactivate: Incomplete
eInputReaderDeactivate: Incomplete
eInputReaderGotToken: Incomplete
eInputReaderInterrupt: Incomplete
eInputReaderEndOfFile: Incomplete
eInputReaderDone: Incomplete
eBreakpointEventTypeInvalidType: Incomplete
eBreakpointEventTypeAdded: Incomplete
eBreakpointEventTypeRemoved: Incomplete
eBreakpointEventTypeLocationsAdded: Incomplete
eBreakpointEventTypeLocationsRemoved: Incomplete
eBreakpointEventTypeLocationsResolved: Incomplete
eBreakpointEventTypeEnabled: Incomplete
eBreakpointEventTypeDisabled: Incomplete
eBreakpointEventTypeCommandChanged: Incomplete
eBreakpointEventTypeConditionChanged: Incomplete
eBreakpointEventTypeIgnoreChanged: Incomplete
eBreakpointEventTypeThreadChanged: Incomplete
eBreakpointEventTypeAutoContinueChanged: Incomplete
eWatchpointEventTypeInvalidType: Incomplete
eWatchpointEventTypeAdded: Incomplete
eWatchpointEventTypeRemoved: Incomplete
eWatchpointEventTypeEnabled: Incomplete
eWatchpointEventTypeDisabled: Incomplete
eWatchpointEventTypeCommandChanged: Incomplete
eWatchpointEventTypeConditionChanged: Incomplete
eWatchpointEventTypeIgnoreChanged: Incomplete
eWatchpointEventTypeThreadChanged: Incomplete
eWatchpointEventTypeTypeChanged: Incomplete
eWatchpointWriteTypeDisabled: Incomplete
eWatchpointWriteTypeAlways: Incomplete
eWatchpointWriteTypeOnModify: Incomplete
eLanguageTypeUnknown: Incomplete
eLanguageTypeC89: Incomplete
eLanguageTypeC: Incomplete
eLanguageTypeAda83: Incomplete
eLanguageTypeC_plus_plus: Incomplete
eLanguageTypeCobol74: Incomplete
eLanguageTypeCobol85: Incomplete
eLanguageTypeFortran77: Incomplete
eLanguageTypeFortran90: Incomplete
eLanguageTypePascal83: Incomplete
eLanguageTypeModula2: Incomplete
eLanguageTypeJava: Incomplete
eLanguageTypeC99: Incomplete
eLanguageTypeAda95: Incomplete
eLanguageTypeFortran95: Incomplete
eLanguageTypePLI: Incomplete
eLanguageTypeObjC: Incomplete
eLanguageTypeObjC_plus_plus: Incomplete
eLanguageTypeUPC: Incomplete
eLanguageTypeD: Incomplete
eLanguageTypePython: Incomplete
eLanguageTypeOpenCL: Incomplete
eLanguageTypeGo: Incomplete
eLanguageTypeModula3: Incomplete
eLanguageTypeHaskell: Incomplete
eLanguageTypeC_plus_plus_03: Incomplete
eLanguageTypeC_plus_plus_11: Incomplete
eLanguageTypeOCaml: Incomplete
eLanguageTypeRust: Incomplete
eLanguageTypeC11: Incomplete
eLanguageTypeSwift: Incomplete
eLanguageTypeJulia: Incomplete
eLanguageTypeDylan: Incomplete
eLanguageTypeC_plus_plus_14: Incomplete
eLanguageTypeFortran03: Incomplete
eLanguageTypeFortran08: Incomplete
eLanguageTypeRenderScript: Incomplete
eLanguageTypeBLISS: Incomplete
eLanguageTypeKotlin: Incomplete
eLanguageTypeZig: Incomplete
eLanguageTypeCrystal: Incomplete
eLanguageTypeC_plus_plus_17: Incomplete
eLanguageTypeC_plus_plus_20: Incomplete
eLanguageTypeC17: Incomplete
eLanguageTypeFortran18: Incomplete
eLanguageTypeAda2005: Incomplete
eLanguageTypeAda2012: Incomplete
eLanguageTypeHIP: Incomplete
eLanguageTypeAssembly: Incomplete
eLanguageTypeC_sharp: Incomplete
eLanguageTypeMojo: Incomplete
eLanguageTypeMipsAssembler: Incomplete
eNumLanguageTypes: Incomplete
eInstrumentationRuntimeTypeAddressSanitizer: Incomplete
eInstrumentationRuntimeTypeThreadSanitizer: Incomplete
eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer: Incomplete
eInstrumentationRuntimeTypeMainThreadChecker: Incomplete
eInstrumentationRuntimeTypeSwiftRuntimeReporting: Incomplete
eInstrumentationRuntimeTypeLibsanitizersAsan: Incomplete
eNumInstrumentationRuntimeTypes: Incomplete
eNoDynamicValues: Incomplete
eDynamicCanRunTarget: Incomplete
eDynamicDontRunTarget: Incomplete
eStopShowColumnAnsiOrCaret: Incomplete
eStopShowColumnAnsi: Incomplete
eStopShowColumnCaret: Incomplete
eStopShowColumnNone: Incomplete
eAccessNone: Incomplete
eAccessPublic: Incomplete
eAccessPrivate: Incomplete
eAccessProtected: Incomplete
eAccessPackage: Incomplete
eArgTypeAddress: Incomplete
eArgTypeAddressOrExpression: Incomplete
eArgTypeAliasName: Incomplete
eArgTypeAliasOptions: Incomplete
eArgTypeArchitecture: Incomplete
eArgTypeBoolean: Incomplete
eArgTypeBreakpointID: Incomplete
eArgTypeBreakpointIDRange: Incomplete
eArgTypeBreakpointName: Incomplete
eArgTypeByteSize: Incomplete
eArgTypeClassName: Incomplete
eArgTypeCommandName: Incomplete
eArgTypeCount: Incomplete
eArgTypeDescriptionVerbosity: Incomplete
eArgTypeDirectoryName: Incomplete
eArgTypeDisassemblyFlavor: Incomplete
eArgTypeEndAddress: Incomplete
eArgTypeExpression: Incomplete
eArgTypeExpressionPath: Incomplete
eArgTypeExprFormat: Incomplete
eArgTypeFileLineColumn: Incomplete
eArgTypeFilename: Incomplete
eArgTypeFormat: Incomplete
eArgTypeFrameIndex: Incomplete
eArgTypeFullName: Incomplete
eArgTypeFunctionName: Incomplete
eArgTypeFunctionOrSymbol: Incomplete
eArgTypeGDBFormat: Incomplete
eArgTypeHelpText: Incomplete
eArgTypeIndex: Incomplete
eArgTypeLanguage: Incomplete
eArgTypeLineNum: Incomplete
eArgTypeLogCategory: Incomplete
eArgTypeLogChannel: Incomplete
eArgTypeMethod: Incomplete
eArgTypeName: Incomplete
eArgTypeNewPathPrefix: Incomplete
eArgTypeNumLines: Incomplete
eArgTypeNumberPerLine: Incomplete
eArgTypeOffset: Incomplete
eArgTypeOldPathPrefix: Incomplete
eArgTypeOneLiner: Incomplete
eArgTypePath: Incomplete
eArgTypePermissionsNumber: Incomplete
eArgTypePermissionsString: Incomplete
eArgTypePid: Incomplete
eArgTypePlugin: Incomplete
eArgTypeProcessName: Incomplete
eArgTypePythonClass: Incomplete
eArgTypePythonFunction: Incomplete
eArgTypePythonScript: Incomplete
eArgTypeQueueName: Incomplete
eArgTypeRegisterName: Incomplete
eArgTypeRegularExpression: Incomplete
eArgTypeRunArgs: Incomplete
eArgTypeRunMode: Incomplete
eArgTypeScriptedCommandSynchronicity: Incomplete
eArgTypeScriptLang: Incomplete
eArgTypeSearchWord: Incomplete
eArgTypeSelector: Incomplete
eArgTypeSettingIndex: Incomplete
eArgTypeSettingKey: Incomplete
eArgTypeSettingPrefix: Incomplete
eArgTypeSettingVariableName: Incomplete
eArgTypeShlibName: Incomplete
eArgTypeSourceFile: Incomplete
eArgTypeSortOrder: Incomplete
eArgTypeStartAddress: Incomplete
eArgTypeSummaryString: Incomplete
eArgTypeSymbol: Incomplete
eArgTypeThreadID: Incomplete
eArgTypeThreadIndex: Incomplete
eArgTypeThreadName: Incomplete
eArgTypeTypeName: Incomplete
eArgTypeUnsignedInteger: Incomplete
eArgTypeUnixSignal: Incomplete
eArgTypeVarName: Incomplete
eArgTypeValue: Incomplete
eArgTypeWidth: Incomplete
eArgTypeNone: Incomplete
eArgTypePlatform: Incomplete
eArgTypeWatchpointID: Incomplete
eArgTypeWatchpointIDRange: Incomplete
eArgTypeWatchType: Incomplete
eArgRawInput: Incomplete
eArgTypeCommand: Incomplete
eArgTypeColumnNum: Incomplete
eArgTypeModuleUUID: Incomplete
eArgTypeSaveCoreStyle: Incomplete
eArgTypeLogHandler: Incomplete
eArgTypeSEDStylePair: Incomplete
eArgTypeRecognizerID: Incomplete
eArgTypeConnectURL: Incomplete
eArgTypeTargetID: Incomplete
eArgTypeStopHookID: Incomplete
eArgTypeCompletionType: Incomplete
eArgTypeLastArg: Incomplete
eSymbolTypeAny: Incomplete
eSymbolTypeInvalid: Incomplete
eSymbolTypeAbsolute: Incomplete
eSymbolTypeCode: Incomplete
eSymbolTypeResolver: Incomplete
eSymbolTypeData: Incomplete
eSymbolTypeTrampoline: Incomplete
eSymbolTypeRuntime: Incomplete
eSymbolTypeException: Incomplete
eSymbolTypeSourceFile: Incomplete
eSymbolTypeHeaderFile: Incomplete
eSymbolTypeObjectFile: Incomplete
eSymbolTypeCommonBlock: Incomplete
eSymbolTypeBlock: Incomplete
eSymbolTypeLocal: Incomplete
eSymbolTypeParam: Incomplete
eSymbolTypeVariable: Incomplete
eSymbolTypeVariableType: Incomplete
eSymbolTypeLineEntry: Incomplete
eSymbolTypeLineHeader: Incomplete
eSymbolTypeScopeBegin: Incomplete
eSymbolTypeScopeEnd: Incomplete
eSymbolTypeAdditional: Incomplete
eSymbolTypeCompiler: Incomplete
eSymbolTypeInstrumentation: Incomplete
eSymbolTypeUndefined: Incomplete
eSymbolTypeObjCClass: Incomplete
eSymbolTypeObjCMetaClass: Incomplete
eSymbolTypeObjCIVar: Incomplete
eSymbolTypeReExported: Incomplete
eSectionTypeInvalid: Incomplete
eSectionTypeCode: Incomplete
eSectionTypeContainer: Incomplete
eSectionTypeData: Incomplete
eSectionTypeDataCString: Incomplete
eSectionTypeDataCStringPointers: Incomplete
eSectionTypeDataSymbolAddress: Incomplete
eSectionTypeData4: Incomplete
eSectionTypeData8: Incomplete
eSectionTypeData16: Incomplete
eSectionTypeDataPointers: Incomplete
eSectionTypeDebug: Incomplete
eSectionTypeZeroFill: Incomplete
eSectionTypeDataObjCMessageRefs: Incomplete
eSectionTypeDataObjCCFStrings: Incomplete
eSectionTypeDWARFDebugAbbrev: Incomplete
eSectionTypeDWARFDebugAddr: Incomplete
eSectionTypeDWARFDebugAranges: Incomplete
eSectionTypeDWARFDebugCuIndex: Incomplete
eSectionTypeDWARFDebugFrame: Incomplete
eSectionTypeDWARFDebugInfo: Incomplete
eSectionTypeDWARFDebugLine: Incomplete
eSectionTypeDWARFDebugLoc: Incomplete
eSectionTypeDWARFDebugMacInfo: Incomplete
eSectionTypeDWARFDebugMacro: Incomplete
eSectionTypeDWARFDebugPubNames: Incomplete
eSectionTypeDWARFDebugPubTypes: Incomplete
eSectionTypeDWARFDebugRanges: Incomplete
eSectionTypeDWARFDebugStr: Incomplete
eSectionTypeDWARFDebugStrOffsets: Incomplete
eSectionTypeDWARFAppleNames: Incomplete
eSectionTypeDWARFAppleTypes: Incomplete
eSectionTypeDWARFAppleNamespaces: Incomplete
eSectionTypeDWARFAppleObjC: Incomplete
eSectionTypeELFSymbolTable: Incomplete
eSectionTypeELFDynamicSymbols: Incomplete
eSectionTypeELFRelocationEntries: Incomplete
eSectionTypeELFDynamicLinkInfo: Incomplete
eSectionTypeEHFrame: Incomplete
eSectionTypeARMexidx: Incomplete
eSectionTypeARMextab: Incomplete
eSectionTypeCompactUnwind: Incomplete
eSectionTypeGoSymtab: Incomplete
eSectionTypeAbsoluteAddress: Incomplete
eSectionTypeDWARFGNUDebugAltLink: Incomplete
eSectionTypeDWARFDebugTypes: Incomplete
eSectionTypeDWARFDebugNames: Incomplete
eSectionTypeOther: Incomplete
eSectionTypeDWARFDebugLineStr: Incomplete
eSectionTypeDWARFDebugRngLists: Incomplete
eSectionTypeDWARFDebugLocLists: Incomplete
eSectionTypeDWARFDebugAbbrevDwo: Incomplete
eSectionTypeDWARFDebugInfoDwo: Incomplete
eSectionTypeDWARFDebugStrDwo: Incomplete
eSectionTypeDWARFDebugStrOffsetsDwo: Incomplete
eSectionTypeDWARFDebugTypesDwo: Incomplete
eSectionTypeDWARFDebugRngListsDwo: Incomplete
eSectionTypeDWARFDebugLocDwo: Incomplete
eSectionTypeDWARFDebugLocListsDwo: Incomplete
eSectionTypeDWARFDebugTuIndex: Incomplete
eSectionTypeCTF: Incomplete
eSectionTypeSwiftModules: Incomplete
eEmulateInstructionOptionNone: Incomplete
eEmulateInstructionOptionAutoAdvancePC: Incomplete
eEmulateInstructionOptionIgnoreConditions: Incomplete
eFunctionNameTypeNone: Incomplete
eFunctionNameTypeAuto: Incomplete
eFunctionNameTypeFull: Incomplete
eFunctionNameTypeBase: Incomplete
eFunctionNameTypeMethod: Incomplete
eFunctionNameTypeSelector: Incomplete
eFunctionNameTypeAny: Incomplete
eBasicTypeInvalid: Incomplete
eBasicTypeVoid: Incomplete
eBasicTypeChar: Incomplete
eBasicTypeSignedChar: Incomplete
eBasicTypeUnsignedChar: Incomplete
eBasicTypeWChar: Incomplete
eBasicTypeSignedWChar: Incomplete
eBasicTypeUnsignedWChar: Incomplete
eBasicTypeChar16: Incomplete
eBasicTypeChar32: Incomplete
eBasicTypeChar8: Incomplete
eBasicTypeShort: Incomplete
eBasicTypeUnsignedShort: Incomplete
eBasicTypeInt: Incomplete
eBasicTypeUnsignedInt: Incomplete
eBasicTypeLong: Incomplete
eBasicTypeUnsignedLong: Incomplete
eBasicTypeLongLong: Incomplete
eBasicTypeUnsignedLongLong: Incomplete
eBasicTypeInt128: Incomplete
eBasicTypeUnsignedInt128: Incomplete
eBasicTypeBool: Incomplete
eBasicTypeHalf: Incomplete
eBasicTypeFloat: Incomplete
eBasicTypeDouble: Incomplete
eBasicTypeLongDouble: Incomplete
eBasicTypeFloatComplex: Incomplete
eBasicTypeDoubleComplex: Incomplete
eBasicTypeLongDoubleComplex: Incomplete
eBasicTypeObjCID: Incomplete
eBasicTypeObjCClass: Incomplete
eBasicTypeObjCSel: Incomplete
eBasicTypeNullPtr: Incomplete
eBasicTypeOther: Incomplete
eTraceTypeNone: Incomplete
eTraceTypeProcessorTrace: Incomplete
eStructuredDataTypeInvalid: Incomplete
eStructuredDataTypeNull: Incomplete
eStructuredDataTypeGeneric: Incomplete
eStructuredDataTypeArray: Incomplete
eStructuredDataTypeInteger: Incomplete
eStructuredDataTypeFloat: Incomplete
eStructuredDataTypeBoolean: Incomplete
eStructuredDataTypeString: Incomplete
eStructuredDataTypeDictionary: Incomplete
eStructuredDataTypeSignedInteger: Incomplete
eStructuredDataTypeUnsignedInteger: Incomplete
eTypeClassInvalid: Incomplete
eTypeClassArray: Incomplete
eTypeClassBlockPointer: Incomplete
eTypeClassBuiltin: Incomplete
eTypeClassClass: Incomplete
eTypeClassComplexFloat: Incomplete
eTypeClassComplexInteger: Incomplete
eTypeClassEnumeration: Incomplete
eTypeClassFunction: Incomplete
eTypeClassMemberPointer: Incomplete
eTypeClassObjCObject: Incomplete
eTypeClassObjCInterface: Incomplete
eTypeClassObjCObjectPointer: Incomplete
eTypeClassPointer: Incomplete
eTypeClassReference: Incomplete
eTypeClassStruct: Incomplete
eTypeClassTypedef: Incomplete
eTypeClassUnion: Incomplete
eTypeClassVector: Incomplete
eTypeClassOther: Incomplete
eTypeClassAny: Incomplete
eTemplateArgumentKindNull: Incomplete
eTemplateArgumentKindType: Incomplete
eTemplateArgumentKindDeclaration: Incomplete
eTemplateArgumentKindIntegral: Incomplete
eTemplateArgumentKindTemplate: Incomplete
eTemplateArgumentKindTemplateExpansion: Incomplete
eTemplateArgumentKindExpression: Incomplete
eTemplateArgumentKindPack: Incomplete
eTemplateArgumentKindNullPtr: Incomplete
eTemplateArgumentKindStructuralValue: Incomplete
eFormatterMatchExact: Incomplete
eFormatterMatchRegex: Incomplete
eFormatterMatchCallback: Incomplete
eLastFormatterMatchType: Incomplete
eTypeOptionNone: Incomplete
eTypeOptionCascade: Incomplete
eTypeOptionSkipPointers: Incomplete
eTypeOptionSkipReferences: Incomplete
eTypeOptionHideChildren: Incomplete
eTypeOptionHideValue: Incomplete
eTypeOptionShowOneLiner: Incomplete
eTypeOptionHideNames: Incomplete
eTypeOptionNonCacheable: Incomplete
eTypeOptionHideEmptyAggregates: Incomplete
eTypeOptionFrontEndWantsDereference: Incomplete
eFrameCompareInvalid: Incomplete
eFrameCompareUnknown: Incomplete
eFrameCompareEqual: Incomplete
eFrameCompareSameParent: Incomplete
eFrameCompareYounger: Incomplete
eFrameCompareOlder: Incomplete
eFilePermissionsUserRead: Incomplete
eFilePermissionsUserWrite: Incomplete
eFilePermissionsUserExecute: Incomplete
eFilePermissionsGroupRead: Incomplete
eFilePermissionsGroupWrite: Incomplete
eFilePermissionsGroupExecute: Incomplete
eFilePermissionsWorldRead: Incomplete
eFilePermissionsWorldWrite: Incomplete
eFilePermissionsWorldExecute: Incomplete
eFilePermissionsUserRW: Incomplete
eFileFilePermissionsUserRX: Incomplete
eFilePermissionsUserRWX: Incomplete
eFilePermissionsGroupRW: Incomplete
eFilePermissionsGroupRX: Incomplete
eFilePermissionsGroupRWX: Incomplete
eFilePermissionsWorldRW: Incomplete
eFilePermissionsWorldRX: Incomplete
eFilePermissionsWorldRWX: Incomplete
eFilePermissionsEveryoneR: Incomplete
eFilePermissionsEveryoneW: Incomplete
eFilePermissionsEveryoneX: Incomplete
eFilePermissionsEveryoneRW: Incomplete
eFilePermissionsEveryoneRX: Incomplete
eFilePermissionsEveryoneRWX: Incomplete
eFilePermissionsFileDefault: Incomplete
eFilePermissionsDirectoryDefault: Incomplete
eQueueItemKindUnknown: Incomplete
eQueueItemKindFunction: Incomplete
eQueueItemKindBlock: Incomplete
eQueueKindUnknown: Incomplete
eQueueKindSerial: Incomplete
eQueueKindConcurrent: Incomplete
eExpressionEvaluationParse: Incomplete
eExpressionEvaluationIRGen: Incomplete
eExpressionEvaluationExecution: Incomplete
eExpressionEvaluationComplete: Incomplete
eInstructionControlFlowKindUnknown: Incomplete
eInstructionControlFlowKindOther: Incomplete
eInstructionControlFlowKindCall: Incomplete
eInstructionControlFlowKindReturn: Incomplete
eInstructionControlFlowKindJump: Incomplete
eInstructionControlFlowKindCondJump: Incomplete
eInstructionControlFlowKindFarCall: Incomplete
eInstructionControlFlowKindFarReturn: Incomplete
eInstructionControlFlowKindFarJump: Incomplete
eWatchpointKindWrite: Incomplete
eWatchpointKindRead: Incomplete
eGdbSignalBadAccess: Incomplete
eGdbSignalBadInstruction: Incomplete
eGdbSignalArithmetic: Incomplete
eGdbSignalEmulation: Incomplete
eGdbSignalSoftware: Incomplete
eGdbSignalBreakpoint: Incomplete
ePathTypeLLDBShlibDir: Incomplete
ePathTypeSupportExecutableDir: Incomplete
ePathTypeHeaderDir: Incomplete
ePathTypePythonDir: Incomplete
ePathTypeLLDBSystemPlugins: Incomplete
ePathTypeLLDBUserPlugins: Incomplete
ePathTypeLLDBTempSystemDir: Incomplete
ePathTypeGlobalLLDBTempSystemDir: Incomplete
ePathTypeClangDir: Incomplete
eMemberFunctionKindUnknown: Incomplete
eMemberFunctionKindConstructor: Incomplete
eMemberFunctionKindDestructor: Incomplete
eMemberFunctionKindInstanceMethod: Incomplete
eMemberFunctionKindStaticMethod: Incomplete
eMatchTypeNormal: Incomplete
eMatchTypeRegex: Incomplete
eMatchTypeStartsWith: Incomplete
eTypeHasChildren: Incomplete
eTypeHasValue: Incomplete
eTypeIsArray: Incomplete
eTypeIsBlock: Incomplete
eTypeIsBuiltIn: Incomplete
eTypeIsClass: Incomplete
eTypeIsCPlusPlus: Incomplete
eTypeIsEnumeration: Incomplete
eTypeIsFuncPrototype: Incomplete
eTypeIsMember: Incomplete
eTypeIsObjC: Incomplete
eTypeIsPointer: Incomplete
eTypeIsReference: Incomplete
eTypeIsStructUnion: Incomplete
eTypeIsTemplate: Incomplete
eTypeIsTypedef: Incomplete
eTypeIsVector: Incomplete
eTypeIsScalar: Incomplete
eTypeIsInteger: Incomplete
eTypeIsFloat: Incomplete
eTypeIsComplex: Incomplete
eTypeIsSigned: Incomplete
eTypeInstanceIsPointer: Incomplete
eCommandRequiresTarget: Incomplete
eCommandRequiresProcess: Incomplete
eCommandRequiresThread: Incomplete
eCommandRequiresFrame: Incomplete
eCommandRequiresRegContext: Incomplete
eCommandTryTargetAPILock: Incomplete
eCommandProcessMustBeLaunched: Incomplete
eCommandProcessMustBePaused: Incomplete
eCommandProcessMustBeTraced: Incomplete
eTypeSummaryCapped: Incomplete
eTypeSummaryUncapped: Incomplete
eCommandInterpreterResultSuccess: Incomplete
eCommandInterpreterResultInferiorCrash: Incomplete
eCommandInterpreterResultCommandError: Incomplete
eCommandInterpreterResultQuitRequested: Incomplete
eSaveCoreUnspecified: Incomplete
eSaveCoreFull: Incomplete
eSaveCoreDirtyOnly: Incomplete
eSaveCoreStackOnly: Incomplete
eTraceEventDisabledSW: Incomplete
eTraceEventDisabledHW: Incomplete
eTraceEventCPUChanged: Incomplete
eTraceEventHWClockTick: Incomplete
eTraceEventSyncPoint: Incomplete
eTraceItemKindError: Incomplete
eTraceItemKindEvent: Incomplete
eTraceItemKindInstruction: Incomplete
eTraceCursorSeekTypeBeginning: Incomplete
eTraceCursorSeekTypeCurrent: Incomplete
eTraceCursorSeekTypeEnd: Incomplete
eDWIMPrintVerbosityNone: Incomplete
eDWIMPrintVerbosityExpression: Incomplete
eDWIMPrintVerbosityFull: Incomplete
eWatchPointValueKindInvalid: Incomplete
eWatchPointValueKindVariable: Incomplete
eWatchPointValueKindExpression: Incomplete
eNoCompletion: Incomplete
eSourceFileCompletion: Incomplete
eDiskFileCompletion: Incomplete
eDiskDirectoryCompletion: Incomplete
eSymbolCompletion: Incomplete
eModuleCompletion: Incomplete
eSettingsNameCompletion: Incomplete
ePlatformPluginCompletion: Incomplete
eArchitectureCompletion: Incomplete
eVariablePathCompletion: Incomplete
eRegisterCompletion: Incomplete
eBreakpointCompletion: Incomplete
eProcessPluginCompletion: Incomplete
eDisassemblyFlavorCompletion: Incomplete
eTypeLanguageCompletion: Incomplete
eFrameIndexCompletion: Incomplete
eModuleUUIDCompletion: Incomplete
eStopHookIDCompletion: Incomplete
eThreadIndexCompletion: Incomplete
eWatchpointIDCompletion: Incomplete
eBreakpointNameCompletion: Incomplete
eProcessIDCompletion: Incomplete
eProcessNameCompletion: Incomplete
eRemoteDiskFileCompletion: Incomplete
eRemoteDiskDirectoryCompletion: Incomplete
eTypeCategoryNameCompletion: Incomplete
eCustomCompletion: Incomplete
eThreadIDCompletion: Incomplete
eTerminatorCompletion: Incomplete

class SBAddress:
    """
    A section + offset based address class.

    The SBAddress class allows addresses to be relative to a section
    that can move during runtime due to images (executables, shared
    libraries, bundles, frameworks) being loaded at different
    addresses than the addresses found in the object file that
    represents them on disk. There are currently two types of addresses
    for a section:

    * file addresses
    * load addresses

    File addresses represents the virtual addresses that are in the 'on
    disk' object files. These virtual addresses are converted to be
    relative to unique sections scoped to the object file so that
    when/if the addresses slide when the images are loaded/unloaded
    in memory, we can easily track these changes without having to
    update every object (compile unit ranges, line tables, function
    address ranges, lexical block and inlined subroutine address
    ranges, global and static variables) each time an image is loaded or
    unloaded.

    Load addresses represents the virtual addresses where each section
    ends up getting loaded at runtime. Before executing a program, it
    is common for all of the load addresses to be unresolved. When a
    DynamicLoader plug-in receives notification that shared libraries
    have been loaded/unloaded, the load addresses of the main executable
    and any images (shared libraries) will be  resolved/unresolved. When
    this happens, breakpoints that are in one of these sections can be
    set/cleared.

    See docstring of SBFunction for example usage of SBAddress.
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBAddress self) -> SBAddress
        __init__(SBAddress self, SBAddress rhs) -> SBAddress
        __init__(SBAddress self, SBSection section, lldb::addr_t offset) -> SBAddress
        __init__(SBAddress self, lldb::addr_t load_addr, SBTarget target) -> SBAddress

            Create an address by resolving a load address using the supplied target.
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def __ne__(self, rhs):
        """__ne__(SBAddress self, SBAddress rhs) -> bool"""
    def IsValid(self):
        """IsValid(SBAddress self) -> bool"""
    def Clear(self):
        """Clear(SBAddress self)"""
    def GetFileAddress(self):
        """GetFileAddress(SBAddress self) -> lldb::addr_t"""
    def GetLoadAddress(self, target):
        """GetLoadAddress(SBAddress self, SBTarget target) -> lldb::addr_t"""
    def SetAddress(self, section, offset):
        """SetAddress(SBAddress self, SBSection section, lldb::addr_t offset)"""
    def SetLoadAddress(self, load_addr, target):
        """SetLoadAddress(SBAddress self, lldb::addr_t load_addr, SBTarget target)"""
    def OffsetAddress(self, offset):
        """OffsetAddress(SBAddress self, lldb::addr_t offset) -> bool"""
    def GetDescription(self, description):
        """GetDescription(SBAddress self, SBStream description) -> bool"""
    def GetSymbolContext(self, resolve_scope):
        """
        GetSymbolContext(SBAddress self, uint32_t resolve_scope) -> SBSymbolContext

            GetSymbolContext() and the following can lookup symbol information for a given address.
            An address might refer to code or data from an existing module, or it
            might refer to something on the stack or heap. The following functions
            will only return valid values if the address has been resolved to a code
            or data address using :py:class:`SBAddress.SetLoadAddress' or
            :py:class:`SBTarget.ResolveLoadAddress`.
        """
    def GetSection(self):
        """GetSection(SBAddress self) -> SBSection"""
    def GetOffset(self):
        """GetOffset(SBAddress self) -> lldb::addr_t"""
    def GetModule(self):
        """
        GetModule(SBAddress self) -> SBModule

            GetModule() and the following grab individual objects for a given address and
            are less efficient if you want more than one symbol related objects.
            Use :py:class:`SBAddress.GetSymbolContext` or
            :py:class:`SBTarget.ResolveSymbolContextForAddress` when you want multiple
            debug symbol related objects for an address.
            One or more bits from the SymbolContextItem enumerations can be logically
            OR'ed together to more efficiently retrieve multiple symbol objects.
        """
    def GetCompileUnit(self):
        """GetCompileUnit(SBAddress self) -> SBCompileUnit"""
    def GetFunction(self):
        """GetFunction(SBAddress self) -> SBFunction"""
    def GetBlock(self):
        """GetBlock(SBAddress self) -> SBBlock"""
    def GetSymbol(self):
        """GetSymbol(SBAddress self) -> SBSymbol"""
    def GetLineEntry(self):
        """GetLineEntry(SBAddress self) -> SBLineEntry"""
    def __eq__(self, other): ...
    def __get_load_addr_property__(self):
        """Get the load address for a lldb.SBAddress using the current target. This resolves the SBAddress using the SBTarget from lldb.target so this property can ONLY be used in the interactive script interpreter (i.e. under the lldb script command). For things like Python based commands and breakpoint callbacks use GetLoadAddress instead."""
    def __set_load_addr_property__(self, load_addr):
        """Set the load address for a lldb.SBAddress using the current target. This resolves the SBAddress using the SBTarget from lldb.target so this property can ONLY be used in the interactive script interpreter (i.e. under the lldb script command). For things like Python based commands and breakpoint callbacks use GetLoadAddress instead."""
    def __int__(self) -> int:
        """Convert an address to a load address if there is a process and that process is alive, or to a file address otherwise. This resolves the SBAddress using the SBTarget from lldb.target so this property can ONLY be used in the interactive script interpreter (i.e. under the lldb script command). For things like Python based commands and breakpoint callbacks use GetLoadAddress instead."""
    def __oct__(self):
        """Convert the address to an octal string. This resolves the SBAddress using the SBTarget from lldb.target so this property can ONLY be used in the interactive script interpreter (i.e. under the lldb script command). For things like Python based commands and breakpoint callbacks use GetLoadAddress instead."""
    def __hex__(self):
        """Convert the address to an hex string. This resolves the SBAddress using the SBTarget from lldb.target so this property can ONLY be used in the interactive script interpreter (i.e. under the lldb script command). For things like Python based commands and breakpoint callbacks use GetLoadAddress instead."""
    module: Incomplete
    compile_unit: Incomplete
    line_entry: Incomplete
    function: Incomplete
    block: Incomplete
    symbol: Incomplete
    offset: Incomplete
    section: Incomplete
    file_addr: Incomplete
    load_addr: Incomplete

class SBAttachInfo:
    """Describes how to attach when calling :py:class:`SBTarget.Attach`."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBAttachInfo self) -> SBAttachInfo
        __init__(SBAttachInfo self, lldb::pid_t pid) -> SBAttachInfo
        __init__(SBAttachInfo self, char const * path, bool wait_for) -> SBAttachInfo
        __init__(SBAttachInfo self, char const * path, bool wait_for, bool _async) -> SBAttachInfo
        __init__(SBAttachInfo self, SBAttachInfo rhs) -> SBAttachInfo
        """
    __swig_destroy__: Incomplete
    def GetProcessID(self):
        """GetProcessID(SBAttachInfo self) -> lldb::pid_t"""
    def SetProcessID(self, pid):
        """SetProcessID(SBAttachInfo self, lldb::pid_t pid)"""
    def SetExecutable(self, *args):
        """
        SetExecutable(SBAttachInfo self, char const * path)
        SetExecutable(SBAttachInfo self, SBFileSpec exe_file)
        """
    def GetWaitForLaunch(self):
        """GetWaitForLaunch(SBAttachInfo self) -> bool"""
    def SetWaitForLaunch(self, *args):
        """
        SetWaitForLaunch(SBAttachInfo self, bool b)
        SetWaitForLaunch(SBAttachInfo self, bool b, bool _async)
        """
    def GetIgnoreExisting(self):
        """GetIgnoreExisting(SBAttachInfo self) -> bool"""
    def SetIgnoreExisting(self, b):
        """SetIgnoreExisting(SBAttachInfo self, bool b)"""
    def GetResumeCount(self):
        """GetResumeCount(SBAttachInfo self) -> uint32_t"""
    def SetResumeCount(self, c):
        """SetResumeCount(SBAttachInfo self, uint32_t c)"""
    def GetProcessPluginName(self):
        """GetProcessPluginName(SBAttachInfo self) -> char const *"""
    def SetProcessPluginName(self, plugin_name):
        """SetProcessPluginName(SBAttachInfo self, char const * plugin_name)"""
    def GetUserID(self):
        """GetUserID(SBAttachInfo self) -> uint32_t"""
    def GetGroupID(self):
        """GetGroupID(SBAttachInfo self) -> uint32_t"""
    def UserIDIsValid(self):
        """UserIDIsValid(SBAttachInfo self) -> bool"""
    def GroupIDIsValid(self):
        """GroupIDIsValid(SBAttachInfo self) -> bool"""
    def SetUserID(self, uid):
        """SetUserID(SBAttachInfo self, uint32_t uid)"""
    def SetGroupID(self, gid):
        """SetGroupID(SBAttachInfo self, uint32_t gid)"""
    def GetEffectiveUserID(self):
        """GetEffectiveUserID(SBAttachInfo self) -> uint32_t"""
    def GetEffectiveGroupID(self):
        """GetEffectiveGroupID(SBAttachInfo self) -> uint32_t"""
    def EffectiveUserIDIsValid(self):
        """EffectiveUserIDIsValid(SBAttachInfo self) -> bool"""
    def EffectiveGroupIDIsValid(self):
        """EffectiveGroupIDIsValid(SBAttachInfo self) -> bool"""
    def SetEffectiveUserID(self, uid):
        """SetEffectiveUserID(SBAttachInfo self, uint32_t uid)"""
    def SetEffectiveGroupID(self, gid):
        """SetEffectiveGroupID(SBAttachInfo self, uint32_t gid)"""
    def GetParentProcessID(self):
        """GetParentProcessID(SBAttachInfo self) -> lldb::pid_t"""
    def SetParentProcessID(self, pid):
        """SetParentProcessID(SBAttachInfo self, lldb::pid_t pid)"""
    def ParentProcessIDIsValid(self):
        """ParentProcessIDIsValid(SBAttachInfo self) -> bool"""
    def GetListener(self):
        """GetListener(SBAttachInfo self) -> SBListener"""
    def SetListener(self, listener):
        """SetListener(SBAttachInfo self, SBListener listener)"""
    def GetShadowListener(self):
        """GetShadowListener(SBAttachInfo self) -> SBListener"""
    def SetShadowListener(self, listener):
        """SetShadowListener(SBAttachInfo self, SBListener listener)"""
    def GetScriptedProcessClassName(self):
        """GetScriptedProcessClassName(SBAttachInfo self) -> char const *"""
    def SetScriptedProcessClassName(self, class_name):
        """SetScriptedProcessClassName(SBAttachInfo self, char const * class_name)"""
    def GetScriptedProcessDictionary(self):
        """GetScriptedProcessDictionary(SBAttachInfo self) -> SBStructuredData"""
    def SetScriptedProcessDictionary(self, dict):
        """SetScriptedProcessDictionary(SBAttachInfo self, SBStructuredData dict)"""

class SBBlock:
    """Represents a lexical block. SBFunction contains SBBlock(s)."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBBlock self) -> SBBlock
        __init__(SBBlock self, SBBlock rhs) -> SBBlock
        """
    __swig_destroy__: Incomplete
    def IsInlined(self):
        """
        IsInlined(SBBlock self) -> bool
        Is this block contained within an inlined function?
        """
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBBlock self) -> bool"""
    def GetInlinedName(self):
        """
        GetInlinedName(SBBlock self) -> char const *

            Get the function name if this block represents an inlined function;
            otherwise, return None.
        """
    def GetInlinedCallSiteFile(self):
        """
        GetInlinedCallSiteFile(SBBlock self) -> SBFileSpec

            Get the call site file if this block represents an inlined function;
            otherwise, return an invalid file spec.
        """
    def GetInlinedCallSiteLine(self):
        """
        GetInlinedCallSiteLine(SBBlock self) -> uint32_t

            Get the call site line if this block represents an inlined function;
            otherwise, return 0.
        """
    def GetInlinedCallSiteColumn(self):
        """
        GetInlinedCallSiteColumn(SBBlock self) -> uint32_t

            Get the call site column if this block represents an inlined function;
            otherwise, return 0.
        """
    def GetParent(self):
        """
        GetParent(SBBlock self) -> SBBlock
        Get the parent block.
        """
    def GetSibling(self):
        """
        GetSibling(SBBlock self) -> SBBlock
        Get the sibling block for this block.
        """
    def GetFirstChild(self):
        """
        GetFirstChild(SBBlock self) -> SBBlock
        Get the first child block.
        """
    def GetNumRanges(self):
        """GetNumRanges(SBBlock self) -> uint32_t"""
    def GetRangeStartAddress(self, idx):
        """GetRangeStartAddress(SBBlock self, uint32_t idx) -> SBAddress"""
    def GetRangeEndAddress(self, idx):
        """GetRangeEndAddress(SBBlock self, uint32_t idx) -> SBAddress"""
    def GetRangeIndexForBlockAddress(self, block_addr):
        """GetRangeIndexForBlockAddress(SBBlock self, SBAddress block_addr) -> uint32_t"""
    def GetVariables(self, *args):
        """
        GetVariables(SBBlock self, SBFrame frame, bool arguments, bool locals, bool statics, lldb::DynamicValueType use_dynamic) -> SBValueList
        GetVariables(SBBlock self, SBTarget target, bool arguments, bool locals, bool statics) -> SBValueList
        """
    def GetContainingInlinedBlock(self):
        """
        GetContainingInlinedBlock(SBBlock self) -> SBBlock
        Get the inlined block that is or contains this block.
        """
    def GetDescription(self, description):
        """GetDescription(SBBlock self, SBStream description) -> bool"""
    def get_range_at_index(self, idx): ...
    class ranges_access:
        """A helper object that will lazily hand out an array of lldb.SBAddress that represent address ranges for a block."""
        sbblock: Incomplete
        def __init__(self, sbblock) -> None: ...
        def __len__(self) -> int: ...
        def __getitem__(self, key): ...
    def get_ranges_access_object(self):
        """An accessor function that returns a ranges_access() object which allows lazy block address ranges access."""
    ranges_array: Incomplete
    def get_ranges_array(self):
        """An accessor function that returns an array object that contains all ranges in this block object."""
    def get_call_site(self): ...
    parent: Incomplete
    first_child: Incomplete
    call_site: Incomplete
    sibling: Incomplete
    name: Incomplete
    inlined_block: Incomplete
    range: Incomplete
    ranges: Incomplete
    num_ranges: Incomplete

class SBBreakpoint:
    """
    Represents a logical breakpoint and its associated settings.

    For example (from test/functionalities/breakpoint/breakpoint_ignore_count/
    TestBreakpointIgnoreCount.py),::

        def breakpoint_ignore_count_python(self):
            '''Use Python APIs to set breakpoint ignore count.'''
            exe = os.path.join(os.getcwd(), 'a.out')

            # Create a target by the debugger.
            target = self.dbg.CreateTarget(exe)
            self.assertTrue(target, VALID_TARGET)

            # Now create a breakpoint on main.c by name 'c'.
            breakpoint = target.BreakpointCreateByName('c', 'a.out')
            self.assertTrue(breakpoint and
                            breakpoint.GetNumLocations() == 1,
                            VALID_BREAKPOINT)

            # Get the breakpoint location from breakpoint after we verified that,
            # indeed, it has one location.
            location = breakpoint.GetLocationAtIndex(0)
            self.assertTrue(location and
                            location.IsEnabled(),
                            VALID_BREAKPOINT_LOCATION)

            # Set the ignore count on the breakpoint location.
            location.SetIgnoreCount(2)
            self.assertTrue(location.GetIgnoreCount() == 2,
                            'SetIgnoreCount() works correctly')

            # Now launch the process, and do not stop at entry point.
            process = target.LaunchSimple(None, None, os.getcwd())
            self.assertTrue(process, PROCESS_IS_VALID)

            # Frame#0 should be on main.c:37, frame#1 should be on main.c:25, and
            # frame#2 should be on main.c:48.
            #lldbutil.print_stacktraces(process)
            from lldbutil import get_stopped_thread
            thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
            self.assertTrue(thread != None, 'There should be a thread stopped due to breakpoint')
            frame0 = thread.GetFrameAtIndex(0)
            frame1 = thread.GetFrameAtIndex(1)
            frame2 = thread.GetFrameAtIndex(2)
            self.assertTrue(frame0.GetLineEntry().GetLine() == self.line1 and
                            frame1.GetLineEntry().GetLine() == self.line3 and
                            frame2.GetLineEntry().GetLine() == self.line4,
                            STOPPED_DUE_TO_BREAKPOINT_IGNORE_COUNT)

            # The hit count for the breakpoint should be 3.
            self.assertTrue(breakpoint.GetHitCount() == 3)

            process.Continue()

    SBBreakpoint supports breakpoint location iteration, for example,::

        for bl in breakpoint:
            print('breakpoint location load addr: %s' % hex(bl.GetLoadAddress()))
            print('breakpoint location condition: %s' % hex(bl.GetCondition()))

    and rich comparison methods which allow the API program to use,::

        if aBreakpoint == bBreakpoint:
            ...

    to compare two breakpoints for equality.
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBBreakpoint self) -> SBBreakpoint
        __init__(SBBreakpoint self, SBBreakpoint rhs) -> SBBreakpoint
        """
    __swig_destroy__: Incomplete
    def __eq__(self, rhs):
        """__eq__(SBBreakpoint self, SBBreakpoint rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBBreakpoint self, SBBreakpoint rhs) -> bool"""
    def GetID(self):
        """GetID(SBBreakpoint self) -> lldb::break_id_t"""
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBBreakpoint self) -> bool"""
    def ClearAllBreakpointSites(self):
        """ClearAllBreakpointSites(SBBreakpoint self)"""
    def GetTarget(self):
        """GetTarget(SBBreakpoint self) -> SBTarget"""
    def FindLocationByAddress(self, vm_addr):
        """FindLocationByAddress(SBBreakpoint self, lldb::addr_t vm_addr) -> SBBreakpointLocation"""
    def FindLocationIDByAddress(self, vm_addr):
        """FindLocationIDByAddress(SBBreakpoint self, lldb::addr_t vm_addr) -> lldb::break_id_t"""
    def FindLocationByID(self, bp_loc_id):
        """FindLocationByID(SBBreakpoint self, lldb::break_id_t bp_loc_id) -> SBBreakpointLocation"""
    def GetLocationAtIndex(self, index):
        """GetLocationAtIndex(SBBreakpoint self, uint32_t index) -> SBBreakpointLocation"""
    def SetEnabled(self, enable):
        """SetEnabled(SBBreakpoint self, bool enable)"""
    def IsEnabled(self):
        """IsEnabled(SBBreakpoint self) -> bool"""
    def SetOneShot(self, one_shot):
        """SetOneShot(SBBreakpoint self, bool one_shot)"""
    def IsOneShot(self):
        """IsOneShot(SBBreakpoint self) -> bool"""
    def IsInternal(self):
        """IsInternal(SBBreakpoint self) -> bool"""
    def GetHitCount(self):
        """GetHitCount(SBBreakpoint self) -> uint32_t"""
    def SetIgnoreCount(self, count):
        """SetIgnoreCount(SBBreakpoint self, uint32_t count)"""
    def GetIgnoreCount(self):
        """GetIgnoreCount(SBBreakpoint self) -> uint32_t"""
    def SetCondition(self, condition):
        """
        SetCondition(SBBreakpoint self, char const * condition)

            The breakpoint stops only if the condition expression evaluates to true.
        """
    def GetCondition(self):
        """
        GetCondition(SBBreakpoint self) -> char const *

            Get the condition expression for the breakpoint.
        """
    def SetAutoContinue(self, auto_continue):
        """SetAutoContinue(SBBreakpoint self, bool auto_continue)"""
    def GetAutoContinue(self):
        """GetAutoContinue(SBBreakpoint self) -> bool"""
    def SetThreadID(self, sb_thread_id):
        """SetThreadID(SBBreakpoint self, lldb::tid_t sb_thread_id)"""
    def GetThreadID(self):
        """GetThreadID(SBBreakpoint self) -> lldb::tid_t"""
    def SetThreadIndex(self, index):
        """SetThreadIndex(SBBreakpoint self, uint32_t index)"""
    def GetThreadIndex(self):
        """GetThreadIndex(SBBreakpoint self) -> uint32_t"""
    def SetThreadName(self, thread_name):
        """SetThreadName(SBBreakpoint self, char const * thread_name)"""
    def GetThreadName(self):
        """GetThreadName(SBBreakpoint self) -> char const *"""
    def SetQueueName(self, queue_name):
        """SetQueueName(SBBreakpoint self, char const * queue_name)"""
    def GetQueueName(self):
        """GetQueueName(SBBreakpoint self) -> char const *"""
    def SetScriptCallbackFunction(self, *args):
        """
        SetScriptCallbackFunction(SBBreakpoint self, char const * callback_function_name)
        SetScriptCallbackFunction(SBBreakpoint self, char const * callback_function_name, SBStructuredData extra_args) -> SBError

            Set the name of the script function to be called when the breakpoint is hit.
            To use this variant, the function should take (frame, bp_loc, extra_args, internal_dict) and
            when the breakpoint is hit the extra_args will be passed to the callback function.
        """
    def SetCommandLineCommands(self, commands):
        """SetCommandLineCommands(SBBreakpoint self, SBStringList commands)"""
    def GetCommandLineCommands(self, commands):
        """GetCommandLineCommands(SBBreakpoint self, SBStringList commands) -> bool"""
    def SetScriptCallbackBody(self, script_body_text):
        """
        SetScriptCallbackBody(SBBreakpoint self, char const * script_body_text) -> SBError

            Provide the body for the script function to be called when the breakpoint is hit.
            The body will be wrapped in a function, which be passed two arguments:
            'frame' - which holds the bottom-most SBFrame of the thread that hit the breakpoint
            'bpno'  - which is the SBBreakpointLocation to which the callback was attached.

            The error parameter is currently ignored, but will at some point hold the Python
            compilation diagnostics.
            Returns true if the body compiles successfully, false if not.
        """
    def AddName(self, new_name):
        """AddName(SBBreakpoint self, char const * new_name) -> bool"""
    def AddNameWithErrorHandling(self, new_name):
        """AddNameWithErrorHandling(SBBreakpoint self, char const * new_name) -> SBError"""
    def RemoveName(self, name_to_remove):
        """RemoveName(SBBreakpoint self, char const * name_to_remove)"""
    def MatchesName(self, name):
        """MatchesName(SBBreakpoint self, char const * name) -> bool"""
    def GetNames(self, names):
        """GetNames(SBBreakpoint self, SBStringList names)"""
    def GetNumResolvedLocations(self):
        """GetNumResolvedLocations(SBBreakpoint self) -> size_t"""
    def GetNumLocations(self):
        """GetNumLocations(SBBreakpoint self) -> size_t"""
    def GetDescription(self, *args):
        """
        GetDescription(SBBreakpoint self, SBStream description) -> bool
        GetDescription(SBBreakpoint self, SBStream description, bool include_locations) -> bool
        """
    @staticmethod
    def EventIsBreakpointEvent(event):
        """EventIsBreakpointEvent(SBEvent event) -> bool"""
    @staticmethod
    def GetBreakpointEventTypeFromEvent(event):
        """GetBreakpointEventTypeFromEvent(SBEvent event) -> lldb::BreakpointEventType"""
    @staticmethod
    def GetBreakpointFromEvent(event):
        """GetBreakpointFromEvent(SBEvent event) -> SBBreakpoint"""
    @staticmethod
    def GetBreakpointLocationAtIndexFromEvent(event, loc_idx):
        """GetBreakpointLocationAtIndexFromEvent(SBEvent event, uint32_t loc_idx) -> SBBreakpointLocation"""
    @staticmethod
    def GetNumBreakpointLocationsFromEvent(event_sp):
        """GetNumBreakpointLocationsFromEvent(SBEvent event_sp) -> uint32_t"""
    def IsHardware(self):
        """IsHardware(SBBreakpoint self) -> bool"""
    def AddLocation(self, address):
        """AddLocation(SBBreakpoint self, SBAddress address) -> SBError"""
    def SerializeToStructuredData(self):
        """SerializeToStructuredData(SBBreakpoint self) -> SBStructuredData"""
    class locations_access:
        """A helper object that will lazily hand out locations for a breakpoint when supplied an index."""
        sbbreakpoint: Incomplete
        def __init__(self, sbbreakpoint) -> None: ...
        def __len__(self) -> int: ...
        def __getitem__(self, key): ...
    def get_locations_access_object(self):
        """An accessor function that returns a locations_access() object which allows lazy location access from a lldb.SBBreakpoint object."""
    def get_breakpoint_location_list(self):
        """An accessor function that returns a list() that contains all locations in a lldb.SBBreakpoint object."""
    def __iter__(self):
        """Iterate over all breakpoint locations in a lldb.SBBreakpoint
        object."""
    def __len__(self) -> int:
        """Return the number of breakpoint locations in a lldb.SBBreakpoint
        object."""
    locations: Incomplete
    location: Incomplete
    id: Incomplete
    enabled: Incomplete
    one_shot: Incomplete
    num_locations: Incomplete
    def __eq__(self, rhs): ...
    def __ne__(self, rhs): ...

class SBBreakpointList:
    """Represents a list of :py:class:`SBBreakpoint`."""
    thisown: Incomplete
    def __init__(self, target) -> None:
        """__init__(SBBreakpointList self, SBTarget target) -> SBBreakpointList"""
    __swig_destroy__: Incomplete
    def GetSize(self):
        """GetSize(SBBreakpointList self) -> size_t"""
    def GetBreakpointAtIndex(self, idx):
        """GetBreakpointAtIndex(SBBreakpointList self, size_t idx) -> SBBreakpoint"""
    def FindBreakpointByID(self, arg2):
        """FindBreakpointByID(SBBreakpointList self, lldb::break_id_t arg2) -> SBBreakpoint"""
    def Append(self, sb_bkpt):
        """Append(SBBreakpointList self, SBBreakpoint sb_bkpt)"""
    def AppendIfUnique(self, sb_bkpt):
        """AppendIfUnique(SBBreakpointList self, SBBreakpoint sb_bkpt) -> bool"""
    def AppendByID(self, id):
        """AppendByID(SBBreakpointList self, lldb::break_id_t id)"""
    def Clear(self):
        """Clear(SBBreakpointList self)"""
    def __len__(self) -> int:
        """Return the number of breakpoints in a lldb.SBBreakpointList object."""
    def __iter__(self):
        """Iterate over all breakpoints in a lldb.SBBreakpointList object."""

class SBBreakpointLocation:
    """
    Represents one unique instance (by address) of a logical breakpoint.

    A breakpoint location is defined by the breakpoint that produces it,
    and the address that resulted in this particular instantiation.
    Each breakpoint location has its settable options.

    :py:class:`SBBreakpoint` contains SBBreakpointLocation(s). See docstring of SBBreakpoint
    for retrieval of an SBBreakpointLocation from an SBBreakpoint.
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBBreakpointLocation self) -> SBBreakpointLocation
        __init__(SBBreakpointLocation self, SBBreakpointLocation rhs) -> SBBreakpointLocation
        """
    __swig_destroy__: Incomplete
    def GetID(self):
        """GetID(SBBreakpointLocation self) -> lldb::break_id_t"""
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBBreakpointLocation self) -> bool"""
    def GetAddress(self):
        """GetAddress(SBBreakpointLocation self) -> SBAddress"""
    def GetLoadAddress(self):
        """GetLoadAddress(SBBreakpointLocation self) -> lldb::addr_t"""
    def SetEnabled(self, enabled):
        """SetEnabled(SBBreakpointLocation self, bool enabled)"""
    def IsEnabled(self):
        """IsEnabled(SBBreakpointLocation self) -> bool"""
    def GetHitCount(self):
        """GetHitCount(SBBreakpointLocation self) -> uint32_t"""
    def GetIgnoreCount(self):
        """GetIgnoreCount(SBBreakpointLocation self) -> uint32_t"""
    def SetIgnoreCount(self, n):
        """SetIgnoreCount(SBBreakpointLocation self, uint32_t n)"""
    def SetCondition(self, condition):
        """
        SetCondition(SBBreakpointLocation self, char const * condition)

            The breakpoint location stops only if the condition expression evaluates
            to true.
        """
    def GetCondition(self):
        """
        GetCondition(SBBreakpointLocation self) -> char const *

            Get the condition expression for the breakpoint location.
        """
    def SetAutoContinue(self, auto_continue):
        """SetAutoContinue(SBBreakpointLocation self, bool auto_continue)"""
    def GetAutoContinue(self):
        """GetAutoContinue(SBBreakpointLocation self) -> bool"""
    def SetScriptCallbackFunction(self, *args):
        """
        SetScriptCallbackFunction(SBBreakpointLocation self, char const * callback_function_name)
        SetScriptCallbackFunction(SBBreakpointLocation self, char const * callback_function_name, SBStructuredData extra_args) -> SBError

            Set the name of the script function to be called when the breakpoint is hit.
            To use this variant, the function should take (frame, bp_loc, extra_args, internal_dict) and
            when the breakpoint is hit the extra_args will be passed to the callback function.
        """
    def SetScriptCallbackBody(self, script_body_text):
        """
        SetScriptCallbackBody(SBBreakpointLocation self, char const * script_body_text) -> SBError

            Provide the body for the script function to be called when the breakpoint location is hit.
            The body will be wrapped in a function, which be passed two arguments:
            'frame' - which holds the bottom-most SBFrame of the thread that hit the breakpoint
            'bpno'  - which is the SBBreakpointLocation to which the callback was attached.

            The error parameter is currently ignored, but will at some point hold the Python
            compilation diagnostics.
            Returns true if the body compiles successfully, false if not.
        """
    def SetCommandLineCommands(self, commands):
        """SetCommandLineCommands(SBBreakpointLocation self, SBStringList commands)"""
    def GetCommandLineCommands(self, commands):
        """GetCommandLineCommands(SBBreakpointLocation self, SBStringList commands) -> bool"""
    def SetThreadID(self, sb_thread_id):
        """SetThreadID(SBBreakpointLocation self, lldb::tid_t sb_thread_id)"""
    def GetThreadID(self):
        """GetThreadID(SBBreakpointLocation self) -> lldb::tid_t"""
    def SetThreadIndex(self, index):
        """SetThreadIndex(SBBreakpointLocation self, uint32_t index)"""
    def GetThreadIndex(self):
        """GetThreadIndex(SBBreakpointLocation self) -> uint32_t"""
    def SetThreadName(self, thread_name):
        """SetThreadName(SBBreakpointLocation self, char const * thread_name)"""
    def GetThreadName(self):
        """GetThreadName(SBBreakpointLocation self) -> char const *"""
    def SetQueueName(self, queue_name):
        """SetQueueName(SBBreakpointLocation self, char const * queue_name)"""
    def GetQueueName(self):
        """GetQueueName(SBBreakpointLocation self) -> char const *"""
    def IsResolved(self):
        """IsResolved(SBBreakpointLocation self) -> bool"""
    def GetDescription(self, description, level):
        """GetDescription(SBBreakpointLocation self, SBStream description, lldb::DescriptionLevel level) -> bool"""
    def GetBreakpoint(self):
        """GetBreakpoint(SBBreakpointLocation self) -> SBBreakpoint"""
    def __eq__(self, other): ...

class SBBreakpointName:
    """
    Represents a breakpoint name registered in a given :py:class:`SBTarget`.

    Breakpoint names provide a way to act on groups of breakpoints.  When you add a
    name to a group of breakpoints, you can then use the name in all the command
    line lldb commands for that name.  You can also configure the SBBreakpointName
    options and those options will be propagated to any :py:class:`SBBreakpoint` s currently
    using that name.  Adding a name to a breakpoint will also apply any of the
    set options to that breakpoint.

    You can also set permissions on a breakpoint name to disable listing, deleting
    and disabling breakpoints.  That will disallow the given operation for breakpoints
    except when the breakpoint is mentioned by ID.  So for instance deleting all the
    breakpoints won't delete breakpoints so marked.
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBBreakpointName self) -> SBBreakpointName
        __init__(SBBreakpointName self, SBTarget target, char const * name) -> SBBreakpointName
        __init__(SBBreakpointName self, SBBreakpoint bkpt, char const * name) -> SBBreakpointName
        __init__(SBBreakpointName self, SBBreakpointName rhs) -> SBBreakpointName
        """
    __swig_destroy__: Incomplete
    def __eq__(self, rhs):
        """__eq__(SBBreakpointName self, SBBreakpointName rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBBreakpointName self, SBBreakpointName rhs) -> bool"""
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBBreakpointName self) -> bool"""
    def GetName(self):
        """GetName(SBBreakpointName self) -> char const *"""
    def SetEnabled(self, enable):
        """SetEnabled(SBBreakpointName self, bool enable)"""
    def IsEnabled(self):
        """IsEnabled(SBBreakpointName self) -> bool"""
    def SetOneShot(self, one_shot):
        """SetOneShot(SBBreakpointName self, bool one_shot)"""
    def IsOneShot(self):
        """IsOneShot(SBBreakpointName self) -> bool"""
    def SetIgnoreCount(self, count):
        """SetIgnoreCount(SBBreakpointName self, uint32_t count)"""
    def GetIgnoreCount(self):
        """GetIgnoreCount(SBBreakpointName self) -> uint32_t"""
    def SetCondition(self, condition):
        """SetCondition(SBBreakpointName self, char const * condition)"""
    def GetCondition(self):
        """GetCondition(SBBreakpointName self) -> char const *"""
    def SetAutoContinue(self, auto_continue):
        """SetAutoContinue(SBBreakpointName self, bool auto_continue)"""
    def GetAutoContinue(self):
        """GetAutoContinue(SBBreakpointName self) -> bool"""
    def SetThreadID(self, sb_thread_id):
        """SetThreadID(SBBreakpointName self, lldb::tid_t sb_thread_id)"""
    def GetThreadID(self):
        """GetThreadID(SBBreakpointName self) -> lldb::tid_t"""
    def SetThreadIndex(self, index):
        """SetThreadIndex(SBBreakpointName self, uint32_t index)"""
    def GetThreadIndex(self):
        """GetThreadIndex(SBBreakpointName self) -> uint32_t"""
    def SetThreadName(self, thread_name):
        """SetThreadName(SBBreakpointName self, char const * thread_name)"""
    def GetThreadName(self):
        """GetThreadName(SBBreakpointName self) -> char const *"""
    def SetQueueName(self, queue_name):
        """SetQueueName(SBBreakpointName self, char const * queue_name)"""
    def GetQueueName(self):
        """GetQueueName(SBBreakpointName self) -> char const *"""
    def SetScriptCallbackFunction(self, *args):
        """
        SetScriptCallbackFunction(SBBreakpointName self, char const * callback_function_name)
        SetScriptCallbackFunction(SBBreakpointName self, char const * callback_function_name, SBStructuredData extra_args) -> SBError
        """
    def SetCommandLineCommands(self, commands):
        """SetCommandLineCommands(SBBreakpointName self, SBStringList commands)"""
    def GetCommandLineCommands(self, commands):
        """GetCommandLineCommands(SBBreakpointName self, SBStringList commands) -> bool"""
    def SetScriptCallbackBody(self, script_body_text):
        """SetScriptCallbackBody(SBBreakpointName self, char const * script_body_text) -> SBError"""
    def GetHelpString(self):
        """GetHelpString(SBBreakpointName self) -> char const *"""
    def SetHelpString(self, help_string):
        """SetHelpString(SBBreakpointName self, char const * help_string)"""
    def GetAllowList(self):
        """GetAllowList(SBBreakpointName self) -> bool"""
    def SetAllowList(self, value):
        """SetAllowList(SBBreakpointName self, bool value)"""
    def GetAllowDelete(self):
        """GetAllowDelete(SBBreakpointName self) -> bool"""
    def SetAllowDelete(self, value):
        """SetAllowDelete(SBBreakpointName self, bool value)"""
    def GetAllowDisable(self):
        """GetAllowDisable(SBBreakpointName self) -> bool"""
    def SetAllowDisable(self, value):
        """SetAllowDisable(SBBreakpointName self, bool value)"""
    def GetDescription(self, description):
        """GetDescription(SBBreakpointName self, SBStream description) -> bool"""
    def __eq__(self, other): ...

class SBBroadcaster:
    """
    Represents an entity which can broadcast events.

    A default broadcaster is
    associated with an SBCommandInterpreter, SBProcess, and SBTarget.  For
    example, use ::

        broadcaster = process.GetBroadcaster()

    to retrieve the process's broadcaster.

    See also SBEvent for example usage of interacting with a broadcaster.
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBBroadcaster self) -> SBBroadcaster
        __init__(SBBroadcaster self, char const * name) -> SBBroadcaster
        __init__(SBBroadcaster self, SBBroadcaster rhs) -> SBBroadcaster
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBBroadcaster self) -> bool"""
    def Clear(self):
        """Clear(SBBroadcaster self)"""
    def BroadcastEventByType(self, event_type, unique: bool = False):
        """BroadcastEventByType(SBBroadcaster self, uint32_t event_type, bool unique=False)"""
    def BroadcastEvent(self, event, unique: bool = False):
        """BroadcastEvent(SBBroadcaster self, SBEvent event, bool unique=False)"""
    def AddInitialEventsToListener(self, listener, requested_events):
        """AddInitialEventsToListener(SBBroadcaster self, SBListener listener, uint32_t requested_events)"""
    def AddListener(self, listener, event_mask):
        """AddListener(SBBroadcaster self, SBListener listener, uint32_t event_mask) -> uint32_t"""
    def GetName(self):
        """GetName(SBBroadcaster self) -> char const *"""
    def EventTypeHasListeners(self, event_type):
        """EventTypeHasListeners(SBBroadcaster self, uint32_t event_type) -> bool"""
    def RemoveListener(self, *args):
        """RemoveListener(SBBroadcaster self, SBListener listener, uint32_t event_mask=4294967295U) -> bool"""
    def __eq__(self, rhs):
        """__eq__(SBBroadcaster self, SBBroadcaster rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBBroadcaster self, SBBroadcaster rhs) -> bool"""
    def __lt__(self, rhs):
        """__lt__(SBBroadcaster self, SBBroadcaster rhs) -> bool"""
    def __eq__(self, other): ...
    def __eq__(self, rhs): ...
    def __ne__(self, rhs): ...

class SBCommandInterpreter:
    """
    SBCommandInterpreter handles/interprets commands for lldb.

    You get the command interpreter from the :py:class:`SBDebugger` instance.

    For example (from test/ python_api/interpreter/TestCommandInterpreterAPI.py),::

        def command_interpreter_api(self):
            '''Test the SBCommandInterpreter APIs.'''
            exe = os.path.join(os.getcwd(), 'a.out')

            # Create a target by the debugger.
            target = self.dbg.CreateTarget(exe)
            self.assertTrue(target, VALID_TARGET)

            # Retrieve the associated command interpreter from our debugger.
            ci = self.dbg.GetCommandInterpreter()
            self.assertTrue(ci, VALID_COMMAND_INTERPRETER)

            # Exercise some APIs....

            self.assertTrue(ci.HasCommands())
            self.assertTrue(ci.HasAliases())
            self.assertTrue(ci.HasAliasOptions())
            self.assertTrue(ci.CommandExists('breakpoint'))
            self.assertTrue(ci.CommandExists('target'))
            self.assertTrue(ci.CommandExists('platform'))
            self.assertTrue(ci.AliasExists('file'))
            self.assertTrue(ci.AliasExists('run'))
            self.assertTrue(ci.AliasExists('bt'))

            res = lldb.SBCommandReturnObject()
            ci.HandleCommand('breakpoint set -f main.c -l %d' % self.line, res)
            self.assertTrue(res.Succeeded())
            ci.HandleCommand('process launch', res)
            self.assertTrue(res.Succeeded())

            process = ci.GetProcess()
            self.assertTrue(process)

            ...

    The HandleCommand() instance method takes two args: the command string and
    an SBCommandReturnObject instance which encapsulates the result of command
    execution.
    """
    thisown: Incomplete
    eBroadcastBitThreadShouldExit: Incomplete
    eBroadcastBitResetPrompt: Incomplete
    eBroadcastBitQuitCommandReceived: Incomplete
    eBroadcastBitAsynchronousOutputData: Incomplete
    eBroadcastBitAsynchronousErrorData: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBCommandInterpreter self) -> SBCommandInterpreter
        __init__(SBCommandInterpreter self, SBCommandInterpreter rhs) -> SBCommandInterpreter
        """
    __swig_destroy__: Incomplete
    @staticmethod
    def GetArgumentTypeAsCString(arg_type):
        """GetArgumentTypeAsCString(lldb::CommandArgumentType const arg_type) -> char const *"""
    @staticmethod
    def GetArgumentDescriptionAsCString(arg_type):
        """GetArgumentDescriptionAsCString(lldb::CommandArgumentType const arg_type) -> char const *"""
    @staticmethod
    def EventIsCommandInterpreterEvent(event):
        """EventIsCommandInterpreterEvent(SBEvent event) -> bool"""
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBCommandInterpreter self) -> bool"""
    def CommandExists(self, cmd):
        """CommandExists(SBCommandInterpreter self, char const * cmd) -> bool"""
    def UserCommandExists(self, cmd):
        """UserCommandExists(SBCommandInterpreter self, char const * cmd) -> bool"""
    def AliasExists(self, cmd):
        """AliasExists(SBCommandInterpreter self, char const * cmd) -> bool"""
    def GetBroadcaster(self):
        """GetBroadcaster(SBCommandInterpreter self) -> SBBroadcaster"""
    @staticmethod
    def GetBroadcasterClass():
        """GetBroadcasterClass() -> char const *"""
    def HasCommands(self):
        """HasCommands(SBCommandInterpreter self) -> bool"""
    def HasAliases(self):
        """HasAliases(SBCommandInterpreter self) -> bool"""
    def HasAliasOptions(self):
        """HasAliasOptions(SBCommandInterpreter self) -> bool"""
    def IsInteractive(self):
        """IsInteractive(SBCommandInterpreter self) -> bool"""
    def GetProcess(self):
        """GetProcess(SBCommandInterpreter self) -> SBProcess"""
    def GetDebugger(self):
        """GetDebugger(SBCommandInterpreter self) -> SBDebugger"""
    def SourceInitFileInHomeDirectory(self, *args):
        """
        SourceInitFileInHomeDirectory(SBCommandInterpreter self, SBCommandReturnObject result)
        SourceInitFileInHomeDirectory(SBCommandInterpreter self, SBCommandReturnObject result, bool is_repl)
        """
    def SourceInitFileInCurrentWorkingDirectory(self, result):
        """SourceInitFileInCurrentWorkingDirectory(SBCommandInterpreter self, SBCommandReturnObject result)"""
    def HandleCommand(self, *args):
        """
        HandleCommand(SBCommandInterpreter self, char const * command_line, SBCommandReturnObject result, bool add_to_history=False) -> lldb::ReturnStatus
        HandleCommand(SBCommandInterpreter self, char const * command_line, SBExecutionContext exe_ctx, SBCommandReturnObject result, bool add_to_history=False) -> lldb::ReturnStatus
        """
    def HandleCommandsFromFile(self, file, override_context, options, result):
        """HandleCommandsFromFile(SBCommandInterpreter self, SBFileSpec file, SBExecutionContext override_context, SBCommandInterpreterRunOptions options, SBCommandReturnObject result)"""
    def HandleCompletion(self, current_line, cursor_pos, match_start_point, max_return_elements, matches):
        """HandleCompletion(SBCommandInterpreter self, char const * current_line, uint32_t cursor_pos, int match_start_point, int max_return_elements, SBStringList matches) -> int"""
    def HandleCompletionWithDescriptions(self, current_line, cursor_pos, match_start_point, max_return_elements, matches, descriptions):
        """HandleCompletionWithDescriptions(SBCommandInterpreter self, char const * current_line, uint32_t cursor_pos, int match_start_point, int max_return_elements, SBStringList matches, SBStringList descriptions) -> int"""
    def WasInterrupted(self):
        """WasInterrupted(SBCommandInterpreter self) -> bool"""
    def InterruptCommand(self):
        """InterruptCommand(SBCommandInterpreter self) -> bool"""
    def IsActive(self):
        """IsActive(SBCommandInterpreter self) -> bool"""
    def GetIOHandlerControlSequence(self, ch):
        """GetIOHandlerControlSequence(SBCommandInterpreter self, char ch) -> char const *"""
    def GetPromptOnQuit(self):
        """GetPromptOnQuit(SBCommandInterpreter self) -> bool"""
    def SetPromptOnQuit(self, b):
        """SetPromptOnQuit(SBCommandInterpreter self, bool b)"""
    def AllowExitCodeOnQuit(self, allow):
        """AllowExitCodeOnQuit(SBCommandInterpreter self, bool allow)"""
    def HasCustomQuitExitCode(self):
        """HasCustomQuitExitCode(SBCommandInterpreter self) -> bool"""
    def GetQuitStatus(self):
        """GetQuitStatus(SBCommandInterpreter self) -> int"""
    def ResolveCommand(self, command_line, result):
        """ResolveCommand(SBCommandInterpreter self, char const * command_line, SBCommandReturnObject result)"""

class SBCommandInterpreterRunOptions:
    """
    SBCommandInterpreterRunOptions controls how the RunCommandInterpreter runs the code it is fed.

    A default SBCommandInterpreterRunOptions object has:

    * StopOnContinue: false
    * StopOnError:    false
    * StopOnCrash:    false
    * EchoCommands:   true
    * PrintResults:   true
    * PrintErrors:    true
    * AddToHistory:   true


    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBCommandInterpreterRunOptions self) -> SBCommandInterpreterRunOptions
        __init__(SBCommandInterpreterRunOptions self, SBCommandInterpreterRunOptions rhs) -> SBCommandInterpreterRunOptions
        """
    __swig_destroy__: Incomplete
    def GetStopOnContinue(self):
        """GetStopOnContinue(SBCommandInterpreterRunOptions self) -> bool"""
    def SetStopOnContinue(self, arg2):
        """SetStopOnContinue(SBCommandInterpreterRunOptions self, bool arg2)"""
    def GetStopOnError(self):
        """GetStopOnError(SBCommandInterpreterRunOptions self) -> bool"""
    def SetStopOnError(self, arg2):
        """SetStopOnError(SBCommandInterpreterRunOptions self, bool arg2)"""
    def GetStopOnCrash(self):
        """GetStopOnCrash(SBCommandInterpreterRunOptions self) -> bool"""
    def SetStopOnCrash(self, arg2):
        """SetStopOnCrash(SBCommandInterpreterRunOptions self, bool arg2)"""
    def GetEchoCommands(self):
        """GetEchoCommands(SBCommandInterpreterRunOptions self) -> bool"""
    def SetEchoCommands(self, arg2):
        """SetEchoCommands(SBCommandInterpreterRunOptions self, bool arg2)"""
    def GetEchoCommentCommands(self):
        """GetEchoCommentCommands(SBCommandInterpreterRunOptions self) -> bool"""
    def SetEchoCommentCommands(self, echo):
        """SetEchoCommentCommands(SBCommandInterpreterRunOptions self, bool echo)"""
    def GetPrintResults(self):
        """GetPrintResults(SBCommandInterpreterRunOptions self) -> bool"""
    def SetPrintResults(self, arg2):
        """SetPrintResults(SBCommandInterpreterRunOptions self, bool arg2)"""
    def GetPrintErrors(self):
        """GetPrintErrors(SBCommandInterpreterRunOptions self) -> bool"""
    def SetPrintErrors(self, arg2):
        """SetPrintErrors(SBCommandInterpreterRunOptions self, bool arg2)"""
    def GetAddToHistory(self):
        """GetAddToHistory(SBCommandInterpreterRunOptions self) -> bool"""
    def SetAddToHistory(self, arg2):
        """SetAddToHistory(SBCommandInterpreterRunOptions self, bool arg2)"""
    def GetAutoHandleEvents(self):
        """GetAutoHandleEvents(SBCommandInterpreterRunOptions self) -> bool"""
    def SetAutoHandleEvents(self, arg2):
        """SetAutoHandleEvents(SBCommandInterpreterRunOptions self, bool arg2)"""
    def GetSpawnThread(self):
        """GetSpawnThread(SBCommandInterpreterRunOptions self) -> bool"""
    def SetSpawnThread(self, arg2):
        """SetSpawnThread(SBCommandInterpreterRunOptions self, bool arg2)"""

class SBCommandReturnObject:
    """
    Represents a container which holds the result from command execution.
    It works with :py:class:`SBCommandInterpreter.HandleCommand()` to encapsulate the result
    of command execution.

    See :py:class:`SBCommandInterpreter` for example usage of SBCommandReturnObject.
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBCommandReturnObject self) -> SBCommandReturnObject
        __init__(SBCommandReturnObject self, SBCommandReturnObject rhs) -> SBCommandReturnObject
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBCommandReturnObject self) -> bool"""
    def PutOutput(self, *args):
        """
        PutOutput(SBCommandReturnObject self, SBFile file) -> size_t
        PutOutput(SBCommandReturnObject self, lldb::FileSP BORROWED) -> size_t
        """
    def GetOutputSize(self):
        """GetOutputSize(SBCommandReturnObject self) -> size_t"""
    def GetErrorSize(self):
        """GetErrorSize(SBCommandReturnObject self) -> size_t"""
    def PutError(self, *args):
        """
        PutError(SBCommandReturnObject self, SBFile file) -> size_t
        PutError(SBCommandReturnObject self, lldb::FileSP BORROWED) -> size_t
        """
    def Clear(self):
        """Clear(SBCommandReturnObject self)"""
    def GetStatus(self):
        """GetStatus(SBCommandReturnObject self) -> lldb::ReturnStatus"""
    def SetStatus(self, status):
        """SetStatus(SBCommandReturnObject self, lldb::ReturnStatus status)"""
    def Succeeded(self):
        """Succeeded(SBCommandReturnObject self) -> bool"""
    def HasResult(self):
        """HasResult(SBCommandReturnObject self) -> bool"""
    def AppendMessage(self, message):
        """AppendMessage(SBCommandReturnObject self, char const * message)"""
    def AppendWarning(self, message):
        """AppendWarning(SBCommandReturnObject self, char const * message)"""
    def GetDescription(self, description):
        """GetDescription(SBCommandReturnObject self, SBStream description) -> bool"""
    def PutCString(self, string):
        """PutCString(SBCommandReturnObject self, char const * string)"""
    def GetOutput(self, *args):
        """
        GetOutput(SBCommandReturnObject self) -> char const
        GetOutput(SBCommandReturnObject self, bool only_if_no_immediate) -> char const *
        """
    def GetError(self, *args):
        """
        GetError(SBCommandReturnObject self) -> char const
        GetError(SBCommandReturnObject self, bool only_if_no_immediate) -> char const *
        """
    def SetError(self, *args):
        """
        SetError(SBCommandReturnObject self, SBError error, char const * fallback_error_cstr=None)
        SetError(SBCommandReturnObject self, char const * error_cstr)
        """
    def SetImmediateOutputFile(self, *args):
        """
        SetImmediateOutputFile(SBCommandReturnObject self, SBFile file)
        SetImmediateOutputFile(SBCommandReturnObject self, lldb::FileSP BORROWED)
        SetImmediateOutputFile(SBCommandReturnObject self, lldb::FileSP BORROWED, bool transfer_ownership)
        """
    def SetImmediateErrorFile(self, *args):
        """
        SetImmediateErrorFile(SBCommandReturnObject self, SBFile file)
        SetImmediateErrorFile(SBCommandReturnObject self, lldb::FileSP BORROWED)
        SetImmediateErrorFile(SBCommandReturnObject self, lldb::FileSP BORROWED, bool transfer_ownership)
        """
    def Print(self, str):
        """Print(SBCommandReturnObject self, char const * str)"""
    def write(self, str):
        """write(SBCommandReturnObject self, char const * str)"""
    def flush(self):
        """flush(SBCommandReturnObject self)"""

class SBCommunication:
    """Allows sending/receiving data."""
    thisown: Incomplete
    eBroadcastBitDisconnected: Incomplete
    eBroadcastBitReadThreadGotBytes: Incomplete
    eBroadcastBitReadThreadDidExit: Incomplete
    eBroadcastBitReadThreadShouldExit: Incomplete
    eBroadcastBitPacketAvailable: Incomplete
    eAllEventBits: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBCommunication self) -> SBCommunication
        __init__(SBCommunication self, char const * broadcaster_name) -> SBCommunication
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBCommunication self) -> bool"""
    def GetBroadcaster(self):
        """GetBroadcaster(SBCommunication self) -> SBBroadcaster"""
    @staticmethod
    def GetBroadcasterClass():
        """GetBroadcasterClass() -> char const *"""
    def AdoptFileDesriptor(self, fd, owns_fd):
        """AdoptFileDesriptor(SBCommunication self, int fd, bool owns_fd) -> lldb::ConnectionStatus"""
    def Connect(self, url):
        """Connect(SBCommunication self, char const * url) -> lldb::ConnectionStatus"""
    def Disconnect(self):
        """Disconnect(SBCommunication self) -> lldb::ConnectionStatus"""
    def IsConnected(self):
        """IsConnected(SBCommunication self) -> bool"""
    def GetCloseOnEOF(self):
        """GetCloseOnEOF(SBCommunication self) -> bool"""
    def SetCloseOnEOF(self, b):
        """SetCloseOnEOF(SBCommunication self, bool b)"""
    def Read(self, dst, dst_len, timeout_usec, status):
        """Read(SBCommunication self, void * dst, size_t dst_len, uint32_t timeout_usec, lldb::ConnectionStatus & status) -> size_t"""
    def Write(self, src, src_len, status):
        """Write(SBCommunication self, void const * src, size_t src_len, lldb::ConnectionStatus & status) -> size_t"""
    def ReadThreadStart(self):
        """ReadThreadStart(SBCommunication self) -> bool"""
    def ReadThreadStop(self):
        """ReadThreadStop(SBCommunication self) -> bool"""
    def ReadThreadIsRunning(self):
        """ReadThreadIsRunning(SBCommunication self) -> bool"""
    def SetReadThreadBytesReceivedCallback(self, callback, callback_baton):
        """SetReadThreadBytesReceivedCallback(SBCommunication self, lldb::SBCommunication::ReadThreadBytesReceived callback, void * callback_baton) -> bool"""

class SBCompileUnit:
    """
    Represents a compilation unit, or compiled source file.

    SBCompileUnit supports line entry iteration. For example,::

        # Now get the SBSymbolContext from this frame.  We want everything. :-)
        context = frame0.GetSymbolContext(lldb.eSymbolContextEverything)
        ...

        compileUnit = context.GetCompileUnit()

        for lineEntry in compileUnit:
            print('line entry: %s:%d' % (str(lineEntry.GetFileSpec()),
                                        lineEntry.GetLine()))
            print('start addr: %s' % str(lineEntry.GetStartAddress()))
            print('end   addr: %s' % str(lineEntry.GetEndAddress()))

    produces: ::

      line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:20
      start addr: a.out[0x100000d98]
      end   addr: a.out[0x100000da3]
      line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:21
      start addr: a.out[0x100000da3]
      end   addr: a.out[0x100000da9]
      line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:22
      start addr: a.out[0x100000da9]
      end   addr: a.out[0x100000db6]
      line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:23
      start addr: a.out[0x100000db6]
      end   addr: a.out[0x100000dbc]
      ...

    See also :py:class:`SBSymbolContext` and :py:class:`SBLineEntry`
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBCompileUnit self) -> SBCompileUnit
        __init__(SBCompileUnit self, SBCompileUnit rhs) -> SBCompileUnit
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBCompileUnit self) -> bool"""
    def GetFileSpec(self):
        """GetFileSpec(SBCompileUnit self) -> SBFileSpec"""
    def GetNumLineEntries(self):
        """GetNumLineEntries(SBCompileUnit self) -> uint32_t"""
    def GetLineEntryAtIndex(self, idx):
        """GetLineEntryAtIndex(SBCompileUnit self, uint32_t idx) -> SBLineEntry"""
    def FindLineEntryIndex(self, *args):
        """
        FindLineEntryIndex(SBCompileUnit self, SBLineEntry line_entry, bool exact=False) -> uint32_t
        FindLineEntryIndex(SBCompileUnit self, uint32_t start_idx, uint32_t line, SBFileSpec inline_file_spec) -> uint32_t
        FindLineEntryIndex(SBCompileUnit self, uint32_t start_idx, uint32_t line, SBFileSpec inline_file_spec, bool exact) -> uint32_t

             Get the index for a provided line entry in this compile unit.

             @param[in] line_entry
                The SBLineEntry object for which we are looking for the index.

             @param[in] exact
                An optional boolean defaulting to false that ensures that the provided
                line entry has a perfect match in the compile unit.

             @return
                The index of the user-provided line entry. UINT32_MAX if the line entry
                was not found in the compile unit.
        """
    def GetSupportFileAtIndex(self, idx):
        """GetSupportFileAtIndex(SBCompileUnit self, uint32_t idx) -> SBFileSpec"""
    def GetNumSupportFiles(self):
        """GetNumSupportFiles(SBCompileUnit self) -> uint32_t"""
    def FindSupportFileIndex(self, start_idx, sb_file, full):
        """FindSupportFileIndex(SBCompileUnit self, uint32_t start_idx, SBFileSpec sb_file, bool full) -> uint32_t"""
    def GetTypes(self, *args):
        """
        GetTypes(SBCompileUnit self, uint32_t type_mask=eTypeClassAny) -> SBTypeList

             Get all types matching type_mask from debug info in this
             compile unit.

             @param[in] type_mask
                A bitfield that consists of one or more bits logically OR'ed
                together from the lldb::TypeClass enumeration. This allows
                you to request only structure types, or only class, struct
                and union types. Passing in lldb::eTypeClassAny will return
                all types found in the debug information for this compile
                unit.

             @return
                A list of types in this compile unit that match type_mask
        """
    def GetLanguage(self):
        """GetLanguage(SBCompileUnit self) -> lldb::LanguageType"""
    def __eq__(self, rhs):
        """__eq__(SBCompileUnit self, SBCompileUnit rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBCompileUnit self, SBCompileUnit rhs) -> bool"""
    def GetDescription(self, description):
        """GetDescription(SBCompileUnit self, SBStream description) -> bool"""
    def __eq__(self, other): ...
    def __iter__(self):
        """Iterate over all line entries in a lldb.SBCompileUnit object."""
    def __len__(self) -> int:
        """Return the number of line entries in a lldb.SBCompileUnit
        object."""
    file: Incomplete
    num_line_entries: Incomplete
    def __eq__(self, rhs): ...
    def __ne__(self, rhs): ...

class SBData:
    """Represents a data buffer."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBData self) -> SBData
        __init__(SBData self, SBData rhs) -> SBData
        """
    __swig_destroy__: Incomplete
    def GetAddressByteSize(self):
        """GetAddressByteSize(SBData self) -> uint8_t"""
    def SetAddressByteSize(self, addr_byte_size):
        """SetAddressByteSize(SBData self, uint8_t addr_byte_size)"""
    def Clear(self):
        """Clear(SBData self)"""
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBData self) -> bool"""
    def GetByteSize(self):
        """GetByteSize(SBData self) -> size_t"""
    def GetByteOrder(self):
        """GetByteOrder(SBData self) -> lldb::ByteOrder"""
    def SetByteOrder(self, endian):
        """SetByteOrder(SBData self, lldb::ByteOrder endian)"""
    def GetFloat(self, error, offset):
        """GetFloat(SBData self, SBError error, lldb::offset_t offset) -> float"""
    def GetDouble(self, error, offset):
        """GetDouble(SBData self, SBError error, lldb::offset_t offset) -> double"""
    def GetLongDouble(self, error, offset):
        """GetLongDouble(SBData self, SBError error, lldb::offset_t offset) -> long double"""
    def GetAddress(self, error, offset):
        """GetAddress(SBData self, SBError error, lldb::offset_t offset) -> lldb::addr_t"""
    def GetUnsignedInt8(self, error, offset):
        """GetUnsignedInt8(SBData self, SBError error, lldb::offset_t offset) -> uint8_t"""
    def GetUnsignedInt16(self, error, offset):
        """GetUnsignedInt16(SBData self, SBError error, lldb::offset_t offset) -> uint16_t"""
    def GetUnsignedInt32(self, error, offset):
        """GetUnsignedInt32(SBData self, SBError error, lldb::offset_t offset) -> uint32_t"""
    def GetUnsignedInt64(self, error, offset):
        """GetUnsignedInt64(SBData self, SBError error, lldb::offset_t offset) -> uint64_t"""
    def GetSignedInt8(self, error, offset):
        """GetSignedInt8(SBData self, SBError error, lldb::offset_t offset) -> int8_t"""
    def GetSignedInt16(self, error, offset):
        """GetSignedInt16(SBData self, SBError error, lldb::offset_t offset) -> int16_t"""
    def GetSignedInt32(self, error, offset):
        """GetSignedInt32(SBData self, SBError error, lldb::offset_t offset) -> int32_t"""
    def GetSignedInt64(self, error, offset):
        """GetSignedInt64(SBData self, SBError error, lldb::offset_t offset) -> int64_t"""
    def GetString(self, error, offset):
        """GetString(SBData self, SBError error, lldb::offset_t offset) -> char const *"""
    def ReadRawData(self, error, offset, buf):
        """ReadRawData(SBData self, SBError error, lldb::offset_t offset, void * buf) -> size_t"""
    def GetDescription(self, *args):
        """GetDescription(SBData self, SBStream description, lldb::addr_t base_addr=18446744073709551615ULL) -> bool"""
    def SetData(self, error, buf, endian, addr_size):
        """SetData(SBData self, SBError error, void const * buf, lldb::ByteOrder endian, uint8_t addr_size)"""
    def SetDataWithOwnership(self, error, buf, endian, addr_size):
        """SetDataWithOwnership(SBData self, SBError error, void const * buf, lldb::ByteOrder endian, uint8_t addr_size)"""
    def Append(self, rhs):
        """Append(SBData self, SBData rhs) -> bool"""
    @staticmethod
    def CreateDataFromCString(endian, addr_byte_size, data):
        """CreateDataFromCString(lldb::ByteOrder endian, uint32_t addr_byte_size, char const * data) -> SBData"""
    @staticmethod
    def CreateDataFromUInt64Array(endian, addr_byte_size, array):
        """CreateDataFromUInt64Array(lldb::ByteOrder endian, uint32_t addr_byte_size, uint64_t * array) -> SBData"""
    @staticmethod
    def CreateDataFromUInt32Array(endian, addr_byte_size, array):
        """CreateDataFromUInt32Array(lldb::ByteOrder endian, uint32_t addr_byte_size, uint32_t * array) -> SBData"""
    @staticmethod
    def CreateDataFromSInt64Array(endian, addr_byte_size, array):
        """CreateDataFromSInt64Array(lldb::ByteOrder endian, uint32_t addr_byte_size, int64_t * array) -> SBData"""
    @staticmethod
    def CreateDataFromSInt32Array(endian, addr_byte_size, array):
        """CreateDataFromSInt32Array(lldb::ByteOrder endian, uint32_t addr_byte_size, int32_t * array) -> SBData"""
    @staticmethod
    def CreateDataFromDoubleArray(endian, addr_byte_size, array):
        """CreateDataFromDoubleArray(lldb::ByteOrder endian, uint32_t addr_byte_size, double * array) -> SBData"""
    def SetDataFromCString(self, data):
        """SetDataFromCString(SBData self, char const * data) -> bool"""
    def SetDataFromUInt64Array(self, array):
        """SetDataFromUInt64Array(SBData self, uint64_t * array) -> bool"""
    def SetDataFromUInt32Array(self, array):
        """SetDataFromUInt32Array(SBData self, uint32_t * array) -> bool"""
    def SetDataFromSInt64Array(self, array):
        """SetDataFromSInt64Array(SBData self, int64_t * array) -> bool"""
    def SetDataFromSInt32Array(self, array):
        """SetDataFromSInt32Array(SBData self, int32_t * array) -> bool"""
    def SetDataFromDoubleArray(self, array):
        """SetDataFromDoubleArray(SBData self, double * array) -> bool"""
    def __len__(self) -> int: ...
    class read_data_helper:
        sbdata: Incomplete
        readerfunc: Incomplete
        item_size: Incomplete
        def __init__(self, sbdata, readerfunc, item_size) -> None: ...
        def __getitem__(self, key): ...
        def __len__(self) -> int: ...
        def all(self): ...
    @classmethod
    def CreateDataFromInt(cls, value, size: Incomplete | None = None, target: Incomplete | None = None, ptr_size: Incomplete | None = None, endian: Incomplete | None = None): ...
    uint8: Incomplete
    uint16: Incomplete
    uint32: Incomplete
    uint64: Incomplete
    sint8: Incomplete
    sint16: Incomplete
    sint32: Incomplete
    sint64: Incomplete
    float: Incomplete
    double: Incomplete
    uint8s: Incomplete
    uint16s: Incomplete
    uint32s: Incomplete
    uint64s: Incomplete
    sint8s: Incomplete
    sint16s: Incomplete
    sint32s: Incomplete
    sint64s: Incomplete
    floats: Incomplete
    doubles: Incomplete
    byte_order: Incomplete
    size: Incomplete

class SBDebugger:
    """
    SBDebugger is the primordial object that creates SBTargets and provides
    access to them.  It also manages the overall debugging experiences.

    For example (from example/disasm.py),::

        import lldb
        import os
        import sys

        def disassemble_instructions (insts):
            for i in insts:
                print i

        ...

        # Create a new debugger instance
        debugger = lldb.SBDebugger.Create()

        # When we step or continue, don't return from the function until the process
        # stops. We do this by setting the async mode to false.
        debugger.SetAsync (False)

        # Create a target from a file and arch
        print('Creating a target for '%s'' % exe)

        target = debugger.CreateTargetWithFileAndArch (exe, lldb.LLDB_ARCH_DEFAULT)

        if target:
            # If the target is valid set a breakpoint at main
            main_bp = target.BreakpointCreateByName (fname, target.GetExecutable().GetFilename());

            print main_bp

            # Launch the process. Since we specified synchronous mode, we won't return
            # from this function until we hit the breakpoint at main
            process = target.LaunchSimple (None, None, os.getcwd())

            # Make sure the launch went ok
            if process:
                # Print some simple process info
                state = process.GetState ()
                print process
                if state == lldb.eStateStopped:
                    # Get the first thread
                    thread = process.GetThreadAtIndex (0)
                    if thread:
                        # Print some simple thread info
                        print thread
                        # Get the first frame
                        frame = thread.GetFrameAtIndex (0)
                        if frame:
                            # Print some simple frame info
                            print frame
                            function = frame.GetFunction()
                            # See if we have debug info (a function)
                            if function:
                                # We do have a function, print some info for the function
                                print function
                                # Now get all instructions for this function and print them
                                insts = function.GetInstructions(target)
                                disassemble_instructions (insts)
                            else:
                                # See if we have a symbol in the symbol table for where we stopped
                                symbol = frame.GetSymbol();
                                if symbol:
                                    # We do have a symbol, print some info for the symbol
                                    print symbol
                                    # Now get all instructions for this symbol and print them
                                    insts = symbol.GetInstructions(target)
                                    disassemble_instructions (insts)

                            registerList = frame.GetRegisters()
                            print('Frame registers (size of register set = %d):' % registerList.GetSize())
                            for value in registerList:
                                #print value
                                print('%s (number of children = %d):' % (value.GetName(), value.GetNumChildren()))
                                for child in value:
                                    print('Name: ', child.GetName(), ' Value: ', child.GetValue())

                    print('Hit the breakpoint at main, enter to continue and wait for program to exit or 'Ctrl-D'/'quit' to terminate the program')
                    next = sys.stdin.readline()
                    if not next or next.rstrip('\\n') == 'quit':
                        print('Terminating the inferior process...')
                        process.Kill()
                    else:
                        # Now continue to the program exit
                        process.Continue()
                        # When we return from the above function we will hopefully be at the
                        # program exit. Print out some process info
                        print process
                elif state == lldb.eStateExited:
                    print('Didn't hit the breakpoint at main, program has exited...')
                else:
                    print('Unexpected process state: %s, killing process...' % debugger.StateAsCString (state))
                    process.Kill()

    Sometimes you need to create an empty target that will get filled in later.  The most common use for this
    is to attach to a process by name or pid where you don't know the executable up front.  The most convenient way
    to do this is: ::

        target = debugger.CreateTarget('')
        error = lldb.SBError()
        process = target.AttachToProcessWithName(debugger.GetListener(), 'PROCESS_NAME', False, error)

    or the equivalent arguments for :py:class:`SBTarget.AttachToProcessWithID` .
    """
    thisown: Incomplete
    eBroadcastBitProgress: Incomplete
    eBroadcastBitWarning: Incomplete
    eBroadcastBitError: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBDebugger self) -> SBDebugger
        __init__(SBDebugger self, SBDebugger rhs) -> SBDebugger
        """
    __swig_destroy__: Incomplete
    @staticmethod
    def GetBroadcasterClass():
        """GetBroadcasterClass() -> char const *"""
    def GetBroadcaster(self):
        """GetBroadcaster(SBDebugger self) -> SBBroadcaster"""
    @staticmethod
    def GetProgressFromEvent(event):
        """GetProgressFromEvent(SBEvent event) -> char const *"""
    @staticmethod
    def GetProgressDataFromEvent(event):
        """GetProgressDataFromEvent(SBEvent event) -> SBStructuredData"""
    @staticmethod
    def GetDiagnosticFromEvent(event):
        """GetDiagnosticFromEvent(SBEvent event) -> SBStructuredData"""
    @staticmethod
    def Initialize():
        """Initialize()"""
    @staticmethod
    def InitializeWithErrorHandling():
        """InitializeWithErrorHandling() -> SBError"""
    @staticmethod
    def PrintStackTraceOnError():
        """PrintStackTraceOnError()"""
    @staticmethod
    def PrintDiagnosticsOnError():
        """PrintDiagnosticsOnError()"""
    @staticmethod
    def Terminate():
        """Terminate()"""
    @staticmethod
    def Create(*args):
        """
        Create() -> SBDebugger
        Create(bool source_init_files) -> SBDebugger
        Create(bool source_init_files, lldb::LogOutputCallback log_callback) -> SBDebugger
        """
    @staticmethod
    def Destroy(debugger):
        """Destroy(SBDebugger debugger)"""
    @staticmethod
    def MemoryPressureDetected():
        """MemoryPressureDetected()"""
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBDebugger self) -> bool"""
    def Clear(self):
        """Clear(SBDebugger self)"""
    def GetSetting(self, setting: Incomplete | None = None):
        """GetSetting(SBDebugger self, char const * setting=None) -> SBStructuredData"""
    def SetAsync(self, b):
        """SetAsync(SBDebugger self, bool b)"""
    def GetAsync(self):
        """GetAsync(SBDebugger self) -> bool"""
    def SkipLLDBInitFiles(self, b):
        """SkipLLDBInitFiles(SBDebugger self, bool b)"""
    def SkipAppInitFiles(self, b):
        """SkipAppInitFiles(SBDebugger self, bool b)"""
    def SetInputString(self, data):
        """SetInputString(SBDebugger self, char const * data) -> SBError"""
    def SetInputFile(self, *args):
        """
        SetInputFile(SBDebugger self, SBFile file) -> SBError
        SetInputFile(SBDebugger self, lldb::FileSP file) -> SBError
        """
    def SetOutputFile(self, *args):
        """
        SetOutputFile(SBDebugger self, SBFile file) -> SBError
        SetOutputFile(SBDebugger self, lldb::FileSP file) -> SBError
        """
    def SetErrorFile(self, *args):
        """
        SetErrorFile(SBDebugger self, SBFile file) -> SBError
        SetErrorFile(SBDebugger self, lldb::FileSP file) -> SBError
        """
    def GetInputFile(self):
        """GetInputFile(SBDebugger self) -> SBFile"""
    def GetOutputFile(self):
        """GetOutputFile(SBDebugger self) -> SBFile"""
    def GetErrorFile(self):
        """GetErrorFile(SBDebugger self) -> SBFile"""
    def SaveInputTerminalState(self):
        """SaveInputTerminalState(SBDebugger self)"""
    def RestoreInputTerminalState(self):
        """RestoreInputTerminalState(SBDebugger self)"""
    def GetCommandInterpreter(self):
        """GetCommandInterpreter(SBDebugger self) -> SBCommandInterpreter"""
    def HandleCommand(self, command):
        """HandleCommand(SBDebugger self, char const * command)"""
    def RequestInterrupt(self):
        """RequestInterrupt(SBDebugger self)"""
    def CancelInterruptRequest(self):
        """CancelInterruptRequest(SBDebugger self)"""
    def InterruptRequested(self):
        """InterruptRequested(SBDebugger self) -> bool"""
    def GetListener(self):
        """GetListener(SBDebugger self) -> SBListener"""
    def HandleProcessEvent(self, *args):
        """
        HandleProcessEvent(SBDebugger self, SBProcess process, SBEvent event, SBFile out, SBFile err)
        HandleProcessEvent(SBDebugger self, SBProcess process, SBEvent event, lldb::FileSP arg4, lldb::FileSP arg5)
        """
    def CreateTargetWithFileAndTargetTriple(self, filename, target_triple):
        """CreateTargetWithFileAndTargetTriple(SBDebugger self, char const * filename, char const * target_triple) -> SBTarget"""
    def CreateTargetWithFileAndArch(self, filename, archname):
        """CreateTargetWithFileAndArch(SBDebugger self, char const * filename, char const * archname) -> SBTarget"""
    def CreateTarget(self, *args):
        """
        CreateTarget(SBDebugger self, char const * filename, char const * target_triple, char const * platform_name, bool add_dependent_modules, SBError error) -> SBTarget
        CreateTarget(SBDebugger self, char const * filename) -> SBTarget
        """
    def GetDummyTarget(self):
        """
        GetDummyTarget(SBDebugger self) -> SBTarget
        The dummy target holds breakpoints and breakpoint names that will prime newly created targets.
        """
    def DeleteTarget(self, target):
        """
        DeleteTarget(SBDebugger self, SBTarget target) -> bool
        Return true if target is deleted from the target list of the debugger.
        """
    def GetTargetAtIndex(self, idx):
        """GetTargetAtIndex(SBDebugger self, uint32_t idx) -> SBTarget"""
    def GetIndexOfTarget(self, target):
        """GetIndexOfTarget(SBDebugger self, SBTarget target) -> uint32_t"""
    def FindTargetWithProcessID(self, pid):
        """FindTargetWithProcessID(SBDebugger self, lldb::pid_t pid) -> SBTarget"""
    def FindTargetWithFileAndArch(self, filename, arch):
        """FindTargetWithFileAndArch(SBDebugger self, char const * filename, char const * arch) -> SBTarget"""
    def GetNumTargets(self):
        """GetNumTargets(SBDebugger self) -> uint32_t"""
    def GetSelectedTarget(self):
        """GetSelectedTarget(SBDebugger self) -> SBTarget"""
    def SetSelectedTarget(self, target):
        """SetSelectedTarget(SBDebugger self, SBTarget target)"""
    def GetSelectedPlatform(self):
        """GetSelectedPlatform(SBDebugger self) -> SBPlatform"""
    def SetSelectedPlatform(self, platform):
        """SetSelectedPlatform(SBDebugger self, SBPlatform platform)"""
    def GetNumPlatforms(self):
        """
        GetNumPlatforms(SBDebugger self) -> uint32_t
        Get the number of currently active platforms.
        """
    def GetPlatformAtIndex(self, idx):
        """
        GetPlatformAtIndex(SBDebugger self, uint32_t idx) -> SBPlatform
        Get one of the currently active platforms.
        """
    def GetNumAvailablePlatforms(self):
        """
        GetNumAvailablePlatforms(SBDebugger self) -> uint32_t
        Get the number of available platforms.
        """
    def GetAvailablePlatformInfoAtIndex(self, idx):
        """
        GetAvailablePlatformInfoAtIndex(SBDebugger self, uint32_t idx) -> SBStructuredData

            Get the name and description of one of the available platforms.

            @param idx Zero-based index of the platform for which info should be
                       retrieved, must be less than the value returned by
                       GetNumAvailablePlatforms().
        """
    def GetSourceManager(self):
        """GetSourceManager(SBDebugger self) -> SBSourceManager"""
    def SetCurrentPlatform(self, platform_name):
        """SetCurrentPlatform(SBDebugger self, char const * platform_name) -> SBError"""
    def SetCurrentPlatformSDKRoot(self, sysroot):
        """SetCurrentPlatformSDKRoot(SBDebugger self, char const * sysroot) -> bool"""
    def SetUseExternalEditor(self, input):
        """SetUseExternalEditor(SBDebugger self, bool input) -> bool"""
    def GetUseExternalEditor(self):
        """GetUseExternalEditor(SBDebugger self) -> bool"""
    def SetUseColor(self, use_color):
        """SetUseColor(SBDebugger self, bool use_color) -> bool"""
    def GetUseColor(self):
        """GetUseColor(SBDebugger self) -> bool"""
    def SetUseSourceCache(self, use_source_cache):
        """SetUseSourceCache(SBDebugger self, bool use_source_cache) -> bool"""
    def GetUseSourceCache(self):
        """GetUseSourceCache(SBDebugger self) -> bool"""
    @staticmethod
    def GetDefaultArchitecture(arch_name, arch_name_len):
        """GetDefaultArchitecture(char * arch_name, size_t arch_name_len) -> bool"""
    @staticmethod
    def SetDefaultArchitecture(arch_name):
        """SetDefaultArchitecture(char const * arch_name) -> bool"""
    def GetScriptingLanguage(self, script_language_name):
        """GetScriptingLanguage(SBDebugger self, char const * script_language_name) -> lldb::ScriptLanguage"""
    def GetScriptInterpreterInfo(self, arg2):
        """GetScriptInterpreterInfo(SBDebugger self, lldb::ScriptLanguage arg2) -> SBStructuredData"""
    @staticmethod
    def GetVersionString():
        """GetVersionString() -> char const *"""
    @staticmethod
    def StateAsCString(state):
        """StateAsCString(lldb::StateType state) -> char const *"""
    @staticmethod
    def GetBuildConfiguration():
        """GetBuildConfiguration() -> SBStructuredData"""
    @staticmethod
    def StateIsRunningState(state):
        """StateIsRunningState(lldb::StateType state) -> bool"""
    @staticmethod
    def StateIsStoppedState(state):
        """StateIsStoppedState(lldb::StateType state) -> bool"""
    def EnableLog(self, channel, categories):
        """EnableLog(SBDebugger self, char const * channel, char const ** categories) -> bool"""
    def SetLoggingCallback(self, log_callback):
        """SetLoggingCallback(SBDebugger self, lldb::LogOutputCallback log_callback)"""
    def SetDestroyCallback(self, destroy_callback):
        """SetDestroyCallback(SBDebugger self, lldb::SBDebuggerDestroyCallback destroy_callback)"""
    def DispatchInput(self, data):
        """DispatchInput(SBDebugger self, void const * data)"""
    def DispatchInputInterrupt(self):
        """DispatchInputInterrupt(SBDebugger self)"""
    def DispatchInputEndOfFile(self):
        """DispatchInputEndOfFile(SBDebugger self)"""
    def GetInstanceName(self):
        """GetInstanceName(SBDebugger self) -> char const *"""
    @staticmethod
    def FindDebuggerWithID(id):
        """FindDebuggerWithID(int id) -> SBDebugger"""
    @staticmethod
    def SetInternalVariable(var_name, value, debugger_instance_name):
        """SetInternalVariable(char const * var_name, char const * value, char const * debugger_instance_name) -> SBError"""
    @staticmethod
    def GetInternalVariableValue(var_name, debugger_instance_name):
        """GetInternalVariableValue(char const * var_name, char const * debugger_instance_name) -> SBStringList"""
    def GetDescription(self, description):
        """GetDescription(SBDebugger self, SBStream description) -> bool"""
    def GetTerminalWidth(self):
        """GetTerminalWidth(SBDebugger self) -> uint32_t"""
    def SetTerminalWidth(self, term_width):
        """SetTerminalWidth(SBDebugger self, uint32_t term_width)"""
    def GetID(self):
        """GetID(SBDebugger self) -> lldb::user_id_t"""
    def GetPrompt(self):
        """GetPrompt(SBDebugger self) -> char const *"""
    def SetPrompt(self, prompt):
        """SetPrompt(SBDebugger self, char const * prompt)"""
    def GetReproducerPath(self):
        """GetReproducerPath(SBDebugger self) -> char const *"""
    def GetScriptLanguage(self):
        """GetScriptLanguage(SBDebugger self) -> lldb::ScriptLanguage"""
    def SetScriptLanguage(self, script_lang):
        """SetScriptLanguage(SBDebugger self, lldb::ScriptLanguage script_lang)"""
    def GetREPLLanguage(self):
        """GetREPLLanguage(SBDebugger self) -> lldb::LanguageType"""
    def SetREPLLanguage(self, repl_lang):
        """SetREPLLanguage(SBDebugger self, lldb::LanguageType repl_lang)"""
    def GetCloseInputOnEOF(self):
        """GetCloseInputOnEOF(SBDebugger self) -> bool"""
    def SetCloseInputOnEOF(self, b):
        """SetCloseInputOnEOF(SBDebugger self, bool b)"""
    def GetCategory(self, *args):
        """
        GetCategory(SBDebugger self, char const * category_name) -> SBTypeCategory
        GetCategory(SBDebugger self, lldb::LanguageType lang_type) -> SBTypeCategory
        """
    def CreateCategory(self, category_name):
        """CreateCategory(SBDebugger self, char const * category_name) -> SBTypeCategory"""
    def DeleteCategory(self, category_name):
        """DeleteCategory(SBDebugger self, char const * category_name) -> bool"""
    def GetNumCategories(self):
        """GetNumCategories(SBDebugger self) -> uint32_t"""
    def GetCategoryAtIndex(self, arg2):
        """GetCategoryAtIndex(SBDebugger self, uint32_t arg2) -> SBTypeCategory"""
    def GetDefaultCategory(self):
        """GetDefaultCategory(SBDebugger self) -> SBTypeCategory"""
    def GetFormatForType(self, arg2):
        """GetFormatForType(SBDebugger self, SBTypeNameSpecifier arg2) -> SBTypeFormat"""
    def GetSummaryForType(self, arg2):
        """GetSummaryForType(SBDebugger self, SBTypeNameSpecifier arg2) -> SBTypeSummary"""
    def GetFilterForType(self, arg2):
        """GetFilterForType(SBDebugger self, SBTypeNameSpecifier arg2) -> SBTypeFilter"""
    def GetSyntheticForType(self, arg2):
        """GetSyntheticForType(SBDebugger self, SBTypeNameSpecifier arg2) -> SBTypeSynthetic"""
    def RunCommandInterpreter(self, auto_handle_events, spawn_thread, options, num_errors, quit_requested, stopped_for_crash):
        """
        RunCommandInterpreter(SBDebugger self, bool auto_handle_events, bool spawn_thread, SBCommandInterpreterRunOptions options, int & num_errors, bool & quit_requested, bool & stopped_for_crash)
        Launch a command interpreter session. Commands are read from standard input or
        from the input handle specified for the debugger object. Output/errors are
        similarly redirected to standard output/error or the configured handles.

        @param[in] auto_handle_events If true, automatically handle resulting events.
        @param[in] spawn_thread If true, start a new thread for IO handling.
        @param[in] options Parameter collection of type SBCommandInterpreterRunOptions.
        @param[in] num_errors Initial error counter.
        @param[in] quit_requested Initial quit request flag.
        @param[in] stopped_for_crash Initial crash flag.

        @return
        A tuple with the number of errors encountered by the interpreter, a boolean
        indicating whether quitting the interpreter was requested and another boolean
        set to True in case of a crash.

        Example: ::

            # Start an interactive lldb session from a script (with a valid debugger object
            # created beforehand):
            n_errors, quit_requested, has_crashed = debugger.RunCommandInterpreter(True,
                False, lldb.SBCommandInterpreterRunOptions(), 0, False, False)
        """
    def RunREPL(self, language, repl_options):
        """RunREPL(SBDebugger self, lldb::LanguageType language, char const * repl_options) -> SBError"""
    def LoadTraceFromFile(self, error, trace_description_file):
        """LoadTraceFromFile(SBDebugger self, SBError error, SBFileSpec trace_description_file) -> SBTrace"""
    def SetOutputFileHandle(self, file, transfer_ownership) -> None:
        """DEPRECATED, use SetOutputFile"""
    def SetInputFileHandle(self, file, transfer_ownership) -> None:
        """DEPRECATED, use SetInputFile"""
    def SetErrorFileHandle(self, file, transfer_ownership) -> None:
        """DEPRECATED, use SetErrorFile"""
    def __iter__(self):
        """Iterate over all targets in a lldb.SBDebugger object."""
    def __len__(self) -> int:
        """Return the number of targets in a lldb.SBDebugger object."""
    def GetInputFileHandle(self):
        """GetInputFileHandle(SBDebugger self) -> lldb::FileSP"""
    def GetOutputFileHandle(self):
        """GetOutputFileHandle(SBDebugger self) -> lldb::FileSP"""
    def GetErrorFileHandle(self):
        """GetErrorFileHandle(SBDebugger self) -> lldb::FileSP"""

class SBDeclaration:
    """Specifies an association with a line and column for a variable."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBDeclaration self) -> SBDeclaration
        __init__(SBDeclaration self, SBDeclaration rhs) -> SBDeclaration
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBDeclaration self) -> bool"""
    def GetFileSpec(self):
        """GetFileSpec(SBDeclaration self) -> SBFileSpec"""
    def GetLine(self):
        """GetLine(SBDeclaration self) -> uint32_t"""
    def GetColumn(self):
        """GetColumn(SBDeclaration self) -> uint32_t"""
    def SetFileSpec(self, filespec):
        """SetFileSpec(SBDeclaration self, SBFileSpec filespec)"""
    def SetLine(self, line):
        """SetLine(SBDeclaration self, uint32_t line)"""
    def SetColumn(self, column):
        """SetColumn(SBDeclaration self, uint32_t column)"""
    def __eq__(self, rhs):
        """__eq__(SBDeclaration self, SBDeclaration rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBDeclaration self, SBDeclaration rhs) -> bool"""
    def GetDescription(self, description):
        """GetDescription(SBDeclaration self, SBStream description) -> bool"""
    def __eq__(self, other): ...
    file: Incomplete
    line: Incomplete
    column: Incomplete
    def __eq__(self, rhs): ...
    def __ne__(self, rhs): ...

class SBError:
    """
    Represents a container for holding any error code.

    For example (from test/python_api/hello_world/TestHelloWorld.py), ::

        def hello_world_attach_with_id_api(self):
            '''Create target, spawn a process, and attach to it by id.'''

            target = self.dbg.CreateTarget(self.exe)

            # Spawn a new process and don't display the stdout if not in TraceOn() mode.
            import subprocess
            popen = subprocess.Popen([self.exe, 'abc', 'xyz'],
                                     stdout = open(os.devnull, 'w') if not self.TraceOn() else None)

            listener = lldb.SBListener('my.attach.listener')
            error = lldb.SBError()
            process = target.AttachToProcessWithID(listener, popen.pid, error)

            self.assertTrue(error.Success() and process, PROCESS_IS_VALID)

            # Let's check the stack traces of the attached process.
            import lldbutil
            stacktraces = lldbutil.print_stacktraces(process, string_buffer=True)
            self.expect(stacktraces, exe=False,
                substrs = ['main.c:%d' % self.line2,
                           '(int)argc=3'])

            listener = lldb.SBListener('my.attach.listener')
            error = lldb.SBError()
            process = target.AttachToProcessWithID(listener, popen.pid, error)

            self.assertTrue(error.Success() and process, PROCESS_IS_VALID)

    checks that after the attach, there is no error condition by asserting
    that error.Success() is True and we get back a valid process object.

    And (from test/python_api/event/TestEvent.py), ::

            # Now launch the process, and do not stop at entry point.
            error = lldb.SBError()
            process = target.Launch(listener, None, None, None, None, None, None, 0, False, error)
            self.assertTrue(error.Success() and process, PROCESS_IS_VALID)

    checks that after calling the target.Launch() method there's no error
    condition and we get back a void process object.
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBError self) -> SBError
        __init__(SBError self, SBError rhs) -> SBError
        __init__(SBError self, char const * message) -> SBError
        """
    __swig_destroy__: Incomplete
    def GetCString(self):
        """GetCString(SBError self) -> char const *"""
    def Clear(self):
        """Clear(SBError self)"""
    def Fail(self):
        """Fail(SBError self) -> bool"""
    def Success(self):
        """Success(SBError self) -> bool"""
    def GetError(self):
        """GetError(SBError self) -> uint32_t"""
    def GetType(self):
        """GetType(SBError self) -> lldb::ErrorType"""
    def SetError(self, err, type):
        """SetError(SBError self, uint32_t err, lldb::ErrorType type)"""
    def SetErrorToErrno(self):
        """SetErrorToErrno(SBError self)"""
    def SetErrorToGenericError(self):
        """SetErrorToGenericError(SBError self)"""
    def SetErrorString(self, err_str):
        """SetErrorString(SBError self, char const * err_str)"""
    def SetErrorStringWithFormat(self, format, str1: Incomplete | None = None, str2: Incomplete | None = None, str3: Incomplete | None = None):
        """SetErrorStringWithFormat(SBError self, char const * format, char * str1=None, char * str2=None, char * str3=None) -> int"""
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBError self) -> bool"""
    def GetDescription(self, description):
        """GetDescription(SBError self, SBStream description) -> bool"""
    def __int__(self) -> int: ...
    value: Incomplete
    fail: Incomplete
    success: Incomplete
    description: Incomplete
    type: Incomplete

class SBEnvironment:
    """
    Represents the environment of a certain process.

    Example: ::

      for entry in lldb.debugger.GetSelectedTarget().GetEnvironment().GetEntries():
        print(entry)


    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBEnvironment self) -> SBEnvironment
        __init__(SBEnvironment self, SBEnvironment rhs) -> SBEnvironment
        """
    __swig_destroy__: Incomplete
    def Get(self, name):
        """Get(SBEnvironment self, char const * name) -> char const *"""
    def GetNumValues(self):
        """GetNumValues(SBEnvironment self) -> size_t"""
    def GetNameAtIndex(self, index):
        """GetNameAtIndex(SBEnvironment self, size_t index) -> char const *"""
    def GetValueAtIndex(self, index):
        """GetValueAtIndex(SBEnvironment self, size_t index) -> char const *"""
    def GetEntries(self):
        """GetEntries(SBEnvironment self) -> SBStringList"""
    def PutEntry(self, name_and_value):
        """PutEntry(SBEnvironment self, char const * name_and_value)"""
    def SetEntries(self, entries, append):
        """SetEntries(SBEnvironment self, SBStringList entries, bool append)"""
    def Set(self, name, value, overwrite):
        """Set(SBEnvironment self, char const * name, char const * value, bool overwrite) -> bool"""
    def Unset(self, name):
        """Unset(SBEnvironment self, char const * name) -> bool"""
    def Clear(self):
        """Clear(SBEnvironment self)"""

class SBEvent:
    """
    API clients can register to receive events.

    For example, check out the following output: ::

        Try wait for event...
        Event description: 0x103d0bb70 Event: broadcaster = 0x1009c8410, type = 0x00000001, data = { process = 0x1009c8400 (pid = 21528), state = running}
        Event data flavor: Process::ProcessEventData
        Process state: running

        Try wait for event...
        Event description: 0x103a700a0 Event: broadcaster = 0x1009c8410, type = 0x00000001, data = { process = 0x1009c8400 (pid = 21528), state = stopped}
        Event data flavor: Process::ProcessEventData
        Process state: stopped

        Try wait for event...
        Event description: 0x103d0d4a0 Event: broadcaster = 0x1009c8410, type = 0x00000001, data = { process = 0x1009c8400 (pid = 21528), state = exited}
        Event data flavor: Process::ProcessEventData
        Process state: exited

        Try wait for event...
        timeout occurred waiting for event...

    from test/python_api/event/TestEventspy: ::

        def do_listen_for_and_print_event(self):
            '''Create a listener and use SBEvent API to print the events received.'''
            exe = os.path.join(os.getcwd(), 'a.out')

            # Create a target by the debugger.
            target = self.dbg.CreateTarget(exe)
            self.assertTrue(target, VALID_TARGET)

            # Now create a breakpoint on main.c by name 'c'.
            breakpoint = target.BreakpointCreateByName('c', 'a.out')

            # Now launch the process, and do not stop at the entry point.
            process = target.LaunchSimple(None, None, os.getcwd())
            self.assertTrue(process.GetState() == lldb.eStateStopped,
                            PROCESS_STOPPED)

            # Get a handle on the process's broadcaster.
            broadcaster = process.GetBroadcaster()

            # Create an empty event object.
            event = lldb.SBEvent()

            # Create a listener object and register with the broadcaster.
            listener = lldb.SBListener('my listener')
            rc = broadcaster.AddListener(listener, lldb.SBProcess.eBroadcastBitStateChanged)
            self.assertTrue(rc, 'AddListener successfully retruns')

            traceOn = self.TraceOn()
            if traceOn:
                lldbutil.print_stacktraces(process)

            # Create MyListeningThread class to wait for any kind of event.
            import threading
            class MyListeningThread(threading.Thread):
                def run(self):
                    count = 0
                    # Let's only try at most 4 times to retrieve any kind of event.
                    # After that, the thread exits.
                    while not count > 3:
                        if traceOn:
                            print('Try wait for event...')
                        if listener.WaitForEventForBroadcasterWithType(5,
                                                                       broadcaster,
                                                                       lldb.SBProcess.eBroadcastBitStateChanged,
                                                                       event):
                            if traceOn:
                                desc = lldbutil.get_description(event))
                                print('Event description:', desc)
                                print('Event data flavor:', event.GetDataFlavor())
                                print('Process state:', lldbutil.state_type_to_str(process.GetState()))
                                print()
                        else:
                            if traceOn:
                                print 'timeout occurred waiting for event...'
                        count = count + 1
                    return

            # Let's start the listening thread to retrieve the events.
            my_thread = MyListeningThread()
            my_thread.start()

            # Use Python API to continue the process.  The listening thread should be
            # able to receive the state changed events.
            process.Continue()

            # Use Python API to kill the process.  The listening thread should be
            # able to receive the state changed event, too.
            process.Kill()

            # Wait until the 'MyListeningThread' terminates.
            my_thread.join()
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """__init__(self, int type, str data) -> SBEvent (make an event that contains a C string)__init__(self, int type, str data) -> SBEvent (make an event that contains a C string)__init__(self, int type, str data) -> SBEvent (make an event that contains a C string)"""
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBEvent self) -> bool"""
    def GetDataFlavor(self):
        """GetDataFlavor(SBEvent self) -> char const *"""
    def GetType(self):
        """GetType(SBEvent self) -> uint32_t"""
    def GetBroadcaster(self):
        """GetBroadcaster(SBEvent self) -> SBBroadcaster"""
    def GetBroadcasterClass(self):
        """GetBroadcasterClass(SBEvent self) -> char const *"""
    def BroadcasterMatchesRef(self, broadcaster):
        """BroadcasterMatchesRef(SBEvent self, SBBroadcaster broadcaster) -> bool"""
    def Clear(self):
        """Clear(SBEvent self)"""
    @staticmethod
    def GetCStringFromEvent(event):
        """GetCStringFromEvent(SBEvent event) -> char const *"""
    def GetDescription(self, *args):
        """
        GetDescription(SBEvent self, SBStream description) -> bool
        GetDescription(SBEvent self, SBStream description) -> bool
        """

class SBExecutionContext:
    """Describes the program context in which a command should be executed."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBExecutionContext self) -> SBExecutionContext
        __init__(SBExecutionContext self, SBExecutionContext rhs) -> SBExecutionContext
        __init__(SBExecutionContext self, SBTarget target) -> SBExecutionContext
        __init__(SBExecutionContext self, SBProcess process) -> SBExecutionContext
        __init__(SBExecutionContext self, SBThread thread) -> SBExecutionContext
        __init__(SBExecutionContext self, SBFrame frame) -> SBExecutionContext
        """
    __swig_destroy__: Incomplete
    def GetTarget(self):
        """GetTarget(SBExecutionContext self) -> SBTarget"""
    def GetProcess(self) -> SBProcess:
        """GetProcess(SBExecutionContext self) -> SBProcess"""
    def GetThread(self):
        """GetThread(SBExecutionContext self) -> SBThread"""
    def GetFrame(self):
        """GetFrame(SBExecutionContext self) -> SBFrame"""
    target: Incomplete
    process: Incomplete
    thread: Incomplete
    frame: Incomplete

class SBExpressionOptions:
    """A container for options to use when evaluating expressions."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBExpressionOptions self) -> SBExpressionOptions
        __init__(SBExpressionOptions self, SBExpressionOptions rhs) -> SBExpressionOptions
        """
    __swig_destroy__: Incomplete
    def GetCoerceResultToId(self):
        """GetCoerceResultToId(SBExpressionOptions self) -> bool"""
    def SetCoerceResultToId(self, coerce: bool = True):
        """
        SetCoerceResultToId(SBExpressionOptions self, bool coerce=True)
        Sets whether to coerce the expression result to ObjC id type after evaluation.
        """
    def GetUnwindOnError(self):
        """GetUnwindOnError(SBExpressionOptions self) -> bool"""
    def SetUnwindOnError(self, unwind: bool = True):
        """
        SetUnwindOnError(SBExpressionOptions self, bool unwind=True)
        Sets whether to unwind the expression stack on error.
        """
    def GetIgnoreBreakpoints(self):
        """GetIgnoreBreakpoints(SBExpressionOptions self) -> bool"""
    def SetIgnoreBreakpoints(self, ignore: bool = True):
        """
        SetIgnoreBreakpoints(SBExpressionOptions self, bool ignore=True)
        Sets whether to ignore breakpoint hits while running expressions.
        """
    def GetFetchDynamicValue(self):
        """GetFetchDynamicValue(SBExpressionOptions self) -> lldb::DynamicValueType"""
    def SetFetchDynamicValue(self, *args):
        """
        SetFetchDynamicValue(SBExpressionOptions self, lldb::DynamicValueType dynamic=eDynamicCanRunTarget)
        Sets whether to cast the expression result to its dynamic type.
        """
    def GetTimeoutInMicroSeconds(self):
        """GetTimeoutInMicroSeconds(SBExpressionOptions self) -> uint32_t"""
    def SetTimeoutInMicroSeconds(self, timeout: int = 0):
        """
        SetTimeoutInMicroSeconds(SBExpressionOptions self, uint32_t timeout=0)
        Sets the timeout in microseconds to run the expression for. If try all threads is set to true and the expression doesn't complete within the specified timeout, all threads will be resumed for the same timeout to see if the expression will finish.
        """
    def GetOneThreadTimeoutInMicroSeconds(self):
        """GetOneThreadTimeoutInMicroSeconds(SBExpressionOptions self) -> uint32_t"""
    def SetOneThreadTimeoutInMicroSeconds(self, timeout: int = 0):
        """
        SetOneThreadTimeoutInMicroSeconds(SBExpressionOptions self, uint32_t timeout=0)
        Sets the timeout in microseconds to run the expression on one thread before either timing out or trying all threads.
        """
    def GetTryAllThreads(self):
        """GetTryAllThreads(SBExpressionOptions self) -> bool"""
    def SetTryAllThreads(self, run_others: bool = True):
        """
        SetTryAllThreads(SBExpressionOptions self, bool run_others=True)
        Sets whether to run all threads if the expression does not complete on one thread.
        """
    def GetStopOthers(self):
        """GetStopOthers(SBExpressionOptions self) -> bool"""
    def SetStopOthers(self, stop_others: bool = True):
        """
        SetStopOthers(SBExpressionOptions self, bool stop_others=True)
        Sets whether to stop other threads at all while running expressions.  If false, TryAllThreads does nothing.
        """
    def GetTrapExceptions(self):
        """GetTrapExceptions(SBExpressionOptions self) -> bool"""
    def SetTrapExceptions(self, trap_exceptions: bool = True):
        """
        SetTrapExceptions(SBExpressionOptions self, bool trap_exceptions=True)
        Sets whether to abort expression evaluation if an exception is thrown while executing.  Don't set this to false unless you know the function you are calling traps all exceptions itself.
        """
    def SetLanguage(self, language):
        """
        SetLanguage(SBExpressionOptions self, lldb::LanguageType language)
        Sets the language that LLDB should assume the expression is written in
        """
    def GetGenerateDebugInfo(self):
        """GetGenerateDebugInfo(SBExpressionOptions self) -> bool"""
    def SetGenerateDebugInfo(self, b: bool = True):
        """
        SetGenerateDebugInfo(SBExpressionOptions self, bool b=True)
        Sets whether to generate debug information for the expression and also controls if a SBModule is generated.
        """
    def GetSuppressPersistentResult(self):
        """GetSuppressPersistentResult(SBExpressionOptions self) -> bool"""
    def SetSuppressPersistentResult(self, b: bool = False):
        """
        SetSuppressPersistentResult(SBExpressionOptions self, bool b=False)
        Sets whether to produce a persistent result that can be used in future expressions.
        """
    def GetPrefix(self):
        """
        GetPrefix(SBExpressionOptions self) -> char const *
        Gets the prefix to use for this expression.
        """
    def SetPrefix(self, prefix):
        """
        SetPrefix(SBExpressionOptions self, char const * prefix)
        Sets the prefix to use for this expression. This prefix gets inserted after the 'target.expr-prefix' prefix contents, but before the wrapped expression function body.
        """
    def SetAutoApplyFixIts(self, b: bool = True):
        """
        SetAutoApplyFixIts(SBExpressionOptions self, bool b=True)
        Sets whether to auto-apply fix-it hints to the expression being evaluated.
        """
    def GetAutoApplyFixIts(self):
        """
        GetAutoApplyFixIts(SBExpressionOptions self) -> bool
        Gets whether to auto-apply fix-it hints to an expression.
        """
    def SetRetriesWithFixIts(self, retries):
        """
        SetRetriesWithFixIts(SBExpressionOptions self, uint64_t retries)
        Sets how often LLDB should retry applying fix-its to an expression.
        """
    def GetRetriesWithFixIts(self):
        """
        GetRetriesWithFixIts(SBExpressionOptions self) -> uint64_t
        Gets how often LLDB will retry applying fix-its to an expression.
        """
    def GetTopLevel(self):
        """GetTopLevel(SBExpressionOptions self) -> bool"""
    def SetTopLevel(self, b: bool = True):
        """SetTopLevel(SBExpressionOptions self, bool b=True)"""
    def GetAllowJIT(self):
        """
        GetAllowJIT(SBExpressionOptions self) -> bool
        Gets whether to JIT an expression if it cannot be interpreted.
        """
    def SetAllowJIT(self, allow):
        """
        SetAllowJIT(SBExpressionOptions self, bool allow)
        Sets whether to JIT an expression if it cannot be interpreted.
        """

class SBFile:
    """Represents a file."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBFile self) -> SBFile
        __init__(SBFile self, lldb::FileSP file_sp) -> SBFile
        __init__(SBFile self, int fd, char const * mode, bool transfer_ownership) -> SBFile
        initialize a SBFile from a python file object
        """
    __swig_destroy__: Incomplete
    def Read(self, buf):
        """Read(buffer) -> SBError, bytes_read"""
    def Write(self, buf):
        """Write(buffer) -> SBError, written_read"""
    def Flush(self):
        """Flush(SBFile self) -> SBError"""
    def IsValid(self):
        """IsValid(SBFile self) -> bool"""
    def Close(self):
        """Close(SBFile self) -> SBError"""
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def GetFile(self):
        """
        GetFile(SBFile self) -> lldb::FileSP

            Convert this SBFile into a python io.IOBase file object.

            If the SBFile is itself a wrapper around a python file object,
            this will return that original object.

            The file returned from here should be considered borrowed,
            in the sense that you may read and write to it, and flush it,
            etc, but you should not close it.   If you want to close the
            SBFile, call SBFile.Close().

            If there is no underlying python file to unwrap, GetFile will
            use the file descriptor, if available to create a new python
            file object using ``open(fd, mode=..., closefd=False)``

        """
    @staticmethod
    def MakeBorrowed(BORROWED):
        """MakeBorrowed(lldb::FileSP BORROWED) -> SBFile"""
    @staticmethod
    def MakeForcingIOMethods(FORCE_IO_METHODS):
        """MakeForcingIOMethods(lldb::FileSP FORCE_IO_METHODS) -> SBFile"""
    @staticmethod
    def MakeBorrowedForcingIOMethods(BORROWED_FORCE_IO_METHODS):
        """MakeBorrowedForcingIOMethods(lldb::FileSP BORROWED_FORCE_IO_METHODS) -> SBFile"""
    @classmethod
    def Create(cls, file, borrow: bool = False, force_io_methods: bool = False):
        """
        Create a SBFile from a python file object, with options.

        If borrow is set then the underlying file will
        not be closed when the SBFile is closed or destroyed.

        If force_scripting_io is set then the python read/write
        methods will be called even if a file descriptor is available.
        """

class SBFileSpec:
    """
    Represents a file specification that divides the path into a directory and
    basename.  The string values of the paths are put into uniqued string pools
    for fast comparisons and efficient memory usage.

    For example, the following code ::

            lineEntry = context.GetLineEntry()
            self.expect(lineEntry.GetFileSpec().GetDirectory(), 'The line entry should have the correct directory',
                        exe=False,
                substrs = [self.mydir])
            self.expect(lineEntry.GetFileSpec().GetFilename(), 'The line entry should have the correct filename',
                        exe=False,
                substrs = ['main.c'])
            self.assertTrue(lineEntry.GetLine() == self.line,
                            'The line entry's line number should match ')

    gets the line entry from the symbol context when a thread is stopped.
    It gets the file spec corresponding to the line entry and checks that
    the filename and the directory matches what we expect.
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBFileSpec self) -> SBFileSpec
        __init__(SBFileSpec self, SBFileSpec rhs) -> SBFileSpec
        __init__(SBFileSpec self, char const * path) -> SBFileSpec
        __init__(SBFileSpec self, char const * path, bool resolve) -> SBFileSpec
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def __eq__(self, rhs):
        """__eq__(SBFileSpec self, SBFileSpec rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBFileSpec self, SBFileSpec rhs) -> bool"""
    def IsValid(self):
        """IsValid(SBFileSpec self) -> bool"""
    def Exists(self):
        """Exists(SBFileSpec self) -> bool"""
    def ResolveExecutableLocation(self):
        """ResolveExecutableLocation(SBFileSpec self) -> bool"""
    def GetFilename(self):
        """GetFilename(SBFileSpec self) -> char const *"""
    def GetDirectory(self):
        """GetDirectory(SBFileSpec self) -> char const *"""
    def SetFilename(self, filename):
        """SetFilename(SBFileSpec self, char const * filename)"""
    def SetDirectory(self, directory):
        """SetDirectory(SBFileSpec self, char const * directory)"""
    def GetPath(self, dst_path, dst_len):
        """GetPath(SBFileSpec self, char * dst_path, size_t dst_len) -> uint32_t"""
    @staticmethod
    def ResolvePath(src_path, dst_path, dst_len):
        """ResolvePath(char const * src_path, char * dst_path, size_t dst_len) -> int"""
    def GetDescription(self, description):
        """GetDescription(SBFileSpec self, SBStream description) -> bool"""
    def AppendPathComponent(self, file_or_directory):
        """AppendPathComponent(SBFileSpec self, char const * file_or_directory)"""
    def __eq__(self, other): ...
    fullpath: Incomplete
    basename: Incomplete
    dirname: Incomplete
    exists: Incomplete

class SBFileSpecList:
    """Represents a list of :py:class:`SBFileSpec`."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBFileSpecList self) -> SBFileSpecList
        __init__(SBFileSpecList self, SBFileSpecList rhs) -> SBFileSpecList
        """
    __swig_destroy__: Incomplete
    def GetSize(self):
        """GetSize(SBFileSpecList self) -> uint32_t"""
    def GetDescription(self, description):
        """GetDescription(SBFileSpecList self, SBStream description) -> bool"""
    def Append(self, sb_file):
        """Append(SBFileSpecList self, SBFileSpec sb_file)"""
    def AppendIfUnique(self, sb_file):
        """AppendIfUnique(SBFileSpecList self, SBFileSpec sb_file) -> bool"""
    def Clear(self):
        """Clear(SBFileSpecList self)"""
    def FindFileIndex(self, idx, sb_file, full):
        """FindFileIndex(SBFileSpecList self, uint32_t idx, SBFileSpec sb_file, bool full) -> uint32_t"""
    def GetFileSpecAtIndex(self, idx):
        """GetFileSpecAtIndex(SBFileSpecList self, uint32_t idx) -> SBFileSpec"""
    def __len__(self) -> int:
        """Return the number of FileSpec in a lldb.SBFileSpecList object."""
    def __iter__(self):
        """Iterate over all FileSpecs in a lldb.SBFileSpecList object."""

class SBFormat:
    """Class that represents a format string that can be used to generate descriptions of objects like frames and threads. See https://lldb.llvm.org/use/formatting.html for more information."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBFormat self) -> SBFormat
        __init__(SBFormat self, char const * format, SBError error) -> SBFormat
        __init__(SBFormat self, SBFormat rhs) -> SBFormat
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__

class SBFrame:
    """
    Represents one of the stack frames associated with a thread.

    SBThread contains SBFrame(s). For example (from test/lldbutil.py), ::

        def print_stacktrace(thread, string_buffer = False):
            '''Prints a simple stack trace of this thread.'''

            ...

            for i in range(depth):
                frame = thread.GetFrameAtIndex(i)
                function = frame.GetFunction()

                load_addr = addrs[i].GetLoadAddress(target)
                if not function:
                    file_addr = addrs[i].GetFileAddress()
                    start_addr = frame.GetSymbol().GetStartAddress().GetFileAddress()
                    symbol_offset = file_addr - start_addr
                    print >> output, '  frame #{num}: {addr:#016x} {mod}`{symbol} + {offset}'.format(
                        num=i, addr=load_addr, mod=mods[i], symbol=symbols[i], offset=symbol_offset)
                else:
                    print >> output, '  frame #{num}: {addr:#016x} {mod}`{func} at {file}:{line} {args}'.format(
                        num=i, addr=load_addr, mod=mods[i],
                        func='%s [inlined]' % funcs[i] if frame.IsInlined() else funcs[i],
                        file=files[i], line=lines[i],
                        args=get_args_as_string(frame, showFuncName=False) if not frame.IsInlined() else '()')

            ...

    And, ::

        for frame in thread:
            print frame

    See also SBThread.
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBFrame self) -> SBFrame
        __init__(SBFrame self, SBFrame rhs) -> SBFrame
        """
    __swig_destroy__: Incomplete
    def IsEqual(self, that):
        """IsEqual(SBFrame self, SBFrame that) -> bool"""
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBFrame self) -> bool"""
    def GetFrameID(self):
        """GetFrameID(SBFrame self) -> uint32_t"""
    def GetCFA(self):
        """
        GetCFA(SBFrame self) -> lldb::addr_t

            Get the Canonical Frame Address for this stack frame.
            This is the DWARF standard's definition of a CFA, a stack address
            that remains constant throughout the lifetime of the function.
            Returns an lldb::addr_t stack address, or LLDB_INVALID_ADDRESS if
            the CFA cannot be determined.
        """
    def GetPC(self):
        """GetPC(SBFrame self) -> lldb::addr_t"""
    def SetPC(self, new_pc):
        """SetPC(SBFrame self, lldb::addr_t new_pc) -> bool"""
    def GetSP(self):
        """GetSP(SBFrame self) -> lldb::addr_t"""
    def GetFP(self):
        """GetFP(SBFrame self) -> lldb::addr_t"""
    def GetPCAddress(self):
        """GetPCAddress(SBFrame self) -> SBAddress"""
    def GetSymbolContext(self, resolve_scope):
        """GetSymbolContext(SBFrame self, uint32_t resolve_scope) -> SBSymbolContext"""
    def GetModule(self):
        """GetModule(SBFrame self) -> SBModule"""
    def GetCompileUnit(self):
        """GetCompileUnit(SBFrame self) -> SBCompileUnit"""
    def GetFunction(self):
        """GetFunction(SBFrame self) -> SBFunction"""
    def GetSymbol(self):
        """GetSymbol(SBFrame self) -> SBSymbol"""
    def GetBlock(self):
        """
        GetBlock(SBFrame self) -> SBBlock

            Gets the deepest block that contains the frame PC.

            See also GetFrameBlock().
        """
    def GetDisplayFunctionName(self):
        """GetDisplayFunctionName(SBFrame self) -> char const *"""
    def GetFunctionName(self, *args):
        """
        GetFunctionName(SBFrame self) -> char const
        GetFunctionName(SBFrame self) -> char const *

            Get the appropriate function name for this frame. Inlined functions in
            LLDB are represented by Blocks that have inlined function information, so
            just looking at the SBFunction or SBSymbol for a frame isn't enough.
            This function will return the appropriate function, symbol or inlined
            function name for the frame.

            This function returns:
            - the name of the inlined function (if there is one)
            - the name of the concrete function (if there is one)
            - the name of the symbol (if there is one)
            - NULL

            See also IsInlined().
        """
    def GuessLanguage(self):
        """
        GuessLanguage(SBFrame self) -> lldb::LanguageType

            Returns the language of the frame's SBFunction, or if there.
            is no SBFunction, guess the language from the mangled name.
            .
        """
    def IsInlined(self, *args):
        """
        IsInlined(SBFrame self) -> bool
        IsInlined(SBFrame self) -> bool

            Return true if this frame represents an inlined function.

            See also GetFunctionName().
        """
    def IsArtificial(self, *args):
        """
        IsArtificial(SBFrame self) -> bool
        IsArtificial(SBFrame self) -> bool

            Return true if this frame is artificial (e.g a frame synthesized to
            capture a tail call). Local variables may not be available in an artificial
            frame.
        """
    def EvaluateExpression(self, *args) -> SBValue:
        """
        EvaluateExpression(SBFrame self, char const * expr) -> SBValue
        EvaluateExpression(SBFrame self, char const * expr, lldb::DynamicValueType use_dynamic) -> SBValue
        EvaluateExpression(SBFrame self, char const * expr, lldb::DynamicValueType use_dynamic, bool unwind_on_error) -> SBValue
        EvaluateExpression(SBFrame self, char const * expr, SBExpressionOptions options) -> SBValue

            The version that doesn't supply a 'use_dynamic' value will use the
            target's default.
        """
    def GetFrameBlock(self):
        """
        GetFrameBlock(SBFrame self) -> SBBlock

            Gets the lexical block that defines the stack frame. Another way to think
            of this is it will return the block that contains all of the variables
            for a stack frame. Inlined functions are represented as SBBlock objects
            that have inlined function information: the name of the inlined function,
            where it was called from. The block that is returned will be the first
            block at or above the block for the PC (SBFrame::GetBlock()) that defines
            the scope of the frame. When a function contains no inlined functions,
            this will be the top most lexical block that defines the function.
            When a function has inlined functions and the PC is currently
            in one of those inlined functions, this method will return the inlined
            block that defines this frame. If the PC isn't currently in an inlined
            function, the lexical block that defines the function is returned.
        """
    def GetLineEntry(self):
        """GetLineEntry(SBFrame self) -> SBLineEntry"""
    def GetThread(self):
        """GetThread(SBFrame self) -> SBThread"""
    def Disassemble(self):
        """Disassemble(SBFrame self) -> char const *"""
    def Clear(self):
        """Clear(SBFrame self)"""
    def __eq__(self, rhs):
        """__eq__(SBFrame self, SBFrame rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBFrame self, SBFrame rhs) -> bool"""
    def GetVariables(self, *args):
        """
        GetVariables(SBFrame self, bool arguments, bool locals, bool statics, bool in_scope_only) -> SBValueList
        GetVariables(SBFrame self, bool arguments, bool locals, bool statics, bool in_scope_only, lldb::DynamicValueType use_dynamic) -> SBValueList
        GetVariables(SBFrame self, SBVariablesOptions options) -> SBValueList

            The version that doesn't supply a 'use_dynamic' value will use the
            target's default.
        """
    def GetRegisters(self):
        """GetRegisters(SBFrame self) -> SBValueList"""
    def FindRegister(self, name):
        """FindRegister(SBFrame self, char const * name) -> SBValue"""
    def FindVariable(self, *args) -> SBValue:
        """
        FindVariable(SBFrame self, char const * var_name) -> SBValue
        FindVariable(SBFrame self, char const * var_name, lldb::DynamicValueType use_dynamic) -> SBValue

            The version that doesn't supply a 'use_dynamic' value will use the
            target's default.
        """
    def GetValueForVariablePath(self, *args):
        """
        GetValueForVariablePath(SBFrame self, char const * var_expr_cstr, lldb::DynamicValueType use_dynamic) -> SBValue
        GetValueForVariablePath(SBFrame self, char const * var_path) -> SBValue

            Get a lldb.SBValue for a variable path.

            Variable paths can include access to pointer or instance members: ::

                rect_ptr->origin.y
                pt.x

            Pointer dereferences: ::

                *this->foo_ptr
                **argv

            Address of: ::

                &pt
                &my_array[3].x

            Array accesses and treating pointers as arrays: ::

                int_array[1]
                pt_ptr[22].x

            Unlike `EvaluateExpression()` which returns :py:class:`SBValue` objects
            with constant copies of the values at the time of evaluation,
            the result of this function is a value that will continue to
            track the current value of the value as execution progresses
            in the current frame.
        """
    def FindValue(self, *args):
        """
        FindValue(SBFrame self, char const * name, lldb::ValueType value_type) -> SBValue
        FindValue(SBFrame self, char const * name, lldb::ValueType value_type, lldb::DynamicValueType use_dynamic) -> SBValue

            Find variables, register sets, registers, or persistent variables using
            the frame as the scope.

            The version that doesn't supply a ``use_dynamic`` value will use the
            target's default.
        """
    def GetDescription(self, description):
        """GetDescription(SBFrame self, SBStream description) -> bool"""
    def GetDescriptionWithFormat(self, format, output):
        """GetDescriptionWithFormat(SBFrame self, SBFormat format, SBStream output) -> SBError"""
    def __eq__(self, other): ...
    def __int__(self) -> int: ...
    def __hex__(self): ...
    def get_all_variables(self): ...
    def get_parent_frame(self): ...
    def get_arguments(self): ...
    def get_locals(self): ...
    def get_statics(self): ...
    def var(self, var_expr_path):
        """Calls through to lldb.SBFrame.GetValueForVariablePath() and returns
        a value that represents the variable expression path"""
    regs: Incomplete
    def get_registers_access(self): ...
    pc: Incomplete
    addr: Incomplete
    fp: Incomplete
    sp: Incomplete
    module: Incomplete
    compile_unit: Incomplete
    function: Incomplete
    symbol: Incomplete
    block: Incomplete
    is_inlined: Incomplete
    name: Incomplete
    line_entry: Incomplete
    thread: Incomplete
    disassembly: Incomplete
    idx: Incomplete
    variables: Incomplete
    vars: Incomplete
    locals: Incomplete
    args: Incomplete
    arguments: Incomplete
    statics: Incomplete
    registers: Incomplete
    register: Incomplete
    reg: Incomplete
    parent: Incomplete

class SBFunction:
    """
    Represents a generic function, which can be inlined or not.

    For example (from test/lldbutil.py, but slightly modified for doc purpose),::

            ...

            frame = thread.GetFrameAtIndex(i)
            addr = frame.GetPCAddress()
            load_addr = addr.GetLoadAddress(target)
            function = frame.GetFunction()
            mod_name = frame.GetModule().GetFileSpec().GetFilename()

            if not function:
                # No debug info for 'function'.
                symbol = frame.GetSymbol()
                file_addr = addr.GetFileAddress()
                start_addr = symbol.GetStartAddress().GetFileAddress()
                symbol_name = symbol.GetName()
                symbol_offset = file_addr - start_addr
                print >> output, '  frame #{num}: {addr:#016x} {mod}`{symbol} + {offset}'.format(
                    num=i, addr=load_addr, mod=mod_name, symbol=symbol_name, offset=symbol_offset)
            else:
                # Debug info is available for 'function'.
                func_name = frame.GetFunctionName()
                file_name = frame.GetLineEntry().GetFileSpec().GetFilename()
                line_num = frame.GetLineEntry().GetLine()
                print >> output, '  frame #{num}: {addr:#016x} {mod}`{func} at {file}:{line} {args}'.format(
                    num=i, addr=load_addr, mod=mod_name,
                    func='%s [inlined]' % func_name] if frame.IsInlined() else func_name,
                    file=file_name, line=line_num, args=get_args_as_string(frame, showFuncName=False))

            ...
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBFunction self) -> SBFunction
        __init__(SBFunction self, SBFunction rhs) -> SBFunction
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBFunction self) -> bool"""
    def GetName(self):
        """GetName(SBFunction self) -> char const *"""
    def GetDisplayName(self):
        """GetDisplayName(SBFunction self) -> char const *"""
    def GetMangledName(self):
        """GetMangledName(SBFunction self) -> char const *"""
    def GetInstructions(self, *args):
        """
        GetInstructions(SBFunction self, SBTarget target) -> SBInstructionList
        GetInstructions(SBFunction self, SBTarget target, char const * flavor) -> SBInstructionList
        """
    def GetStartAddress(self):
        """GetStartAddress(SBFunction self) -> SBAddress"""
    def GetEndAddress(self):
        """GetEndAddress(SBFunction self) -> SBAddress"""
    def GetArgumentName(self, arg_idx):
        """GetArgumentName(SBFunction self, uint32_t arg_idx) -> char const *"""
    def GetPrologueByteSize(self):
        """GetPrologueByteSize(SBFunction self) -> uint32_t"""
    def GetType(self):
        """GetType(SBFunction self) -> SBType"""
    def GetBlock(self):
        """GetBlock(SBFunction self) -> SBBlock"""
    def GetLanguage(self):
        """GetLanguage(SBFunction self) -> lldb::LanguageType"""
    def GetIsOptimized(self):
        """
        GetIsOptimized(SBFunction self) -> bool

            Returns true if the function was compiled with optimization.
            Optimization, in this case, is meant to indicate that the debugger
            experience may be confusing for the user -- variables optimized away,
            stepping jumping between source lines -- and the driver may want to
            provide some guidance to the user about this.
            Returns false if unoptimized, or unknown.
        """
    def __eq__(self, rhs):
        """__eq__(SBFunction self, SBFunction rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBFunction self, SBFunction rhs) -> bool"""
    def GetDescription(self, description):
        """GetDescription(SBFunction self, SBStream description) -> bool"""
    def __eq__(self, other): ...
    def get_instructions_from_current_target(self): ...
    addr: Incomplete
    end_addr: Incomplete
    block: Incomplete
    instructions: Incomplete
    mangled: Incomplete
    name: Incomplete
    prologue_size: Incomplete
    type: Incomplete
    def __eq__(self, rhs): ...
    def __ne__(self, rhs): ...

class SBHostOS:
    """Provides information about the host system."""
    thisown: Incomplete
    @staticmethod
    def GetProgramFileSpec():
        """GetProgramFileSpec() -> SBFileSpec"""
    @staticmethod
    def GetLLDBPythonPath():
        """GetLLDBPythonPath() -> SBFileSpec"""
    @staticmethod
    def GetLLDBPath(path_type):
        """GetLLDBPath(lldb::PathType path_type) -> SBFileSpec"""
    @staticmethod
    def GetUserHomeDirectory():
        """GetUserHomeDirectory() -> SBFileSpec"""
    @staticmethod
    def ThreadCreated(name):
        """ThreadCreated(char const * name)"""
    @staticmethod
    def ThreadCreate(name, thread_function, thread_arg, err):
        """ThreadCreate(char const * name, lldb::thread_func_t thread_function, void * thread_arg, SBError err) -> lldb::thread_t"""
    @staticmethod
    def ThreadCancel(thread, err):
        """ThreadCancel(lldb::thread_t thread, SBError err) -> bool"""
    @staticmethod
    def ThreadDetach(thread, err):
        """ThreadDetach(lldb::thread_t thread, SBError err) -> bool"""
    @staticmethod
    def ThreadJoin(thread, result, err):
        """ThreadJoin(lldb::thread_t thread, lldb::thread_result_t * result, SBError err) -> bool"""
    def __init__(self) -> None:
        """__init__(SBHostOS self) -> SBHostOS"""
    __swig_destroy__: Incomplete

class SBInstruction:
    """Represents a (machine language) instruction."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBInstruction self) -> SBInstruction
        __init__(SBInstruction self, SBInstruction rhs) -> SBInstruction
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBInstruction self) -> bool"""
    def GetAddress(self):
        """GetAddress(SBInstruction self) -> SBAddress"""
    def GetMnemonic(self, target):
        """GetMnemonic(SBInstruction self, SBTarget target) -> char const *"""
    def GetOperands(self, target):
        """GetOperands(SBInstruction self, SBTarget target) -> char const *"""
    def GetComment(self, target):
        """GetComment(SBInstruction self, SBTarget target) -> char const *"""
    def GetControlFlowKind(self, target):
        """GetControlFlowKind(SBInstruction self, SBTarget target) -> lldb::InstructionControlFlowKind"""
    def GetData(self, target):
        """GetData(SBInstruction self, SBTarget target) -> SBData"""
    def GetByteSize(self):
        """GetByteSize(SBInstruction self) -> size_t"""
    def DoesBranch(self):
        """DoesBranch(SBInstruction self) -> bool"""
    def HasDelaySlot(self):
        """HasDelaySlot(SBInstruction self) -> bool"""
    def CanSetBreakpoint(self):
        """CanSetBreakpoint(SBInstruction self) -> bool"""
    def Print(self, *args):
        """
        Print(SBInstruction self, SBFile out)
        Print(SBInstruction self, lldb::FileSP BORROWED)
        """
    def GetDescription(self, description):
        """GetDescription(SBInstruction self, SBStream description) -> bool"""
    def EmulateWithFrame(self, frame, evaluate_options):
        """EmulateWithFrame(SBInstruction self, SBFrame frame, uint32_t evaluate_options) -> bool"""
    def DumpEmulation(self, triple):
        """DumpEmulation(SBInstruction self, char const * triple) -> bool"""
    def TestEmulation(self, output_stream, test_file):
        """TestEmulation(SBInstruction self, SBStream output_stream, char const * test_file) -> bool"""
    def __hex__(self):
        """ Returns the address of the instruction. """
    def __len__(self) -> int:
        """ Returns the size of the instruction. """
    def __mnemonic_property__(self): ...
    def __operands_property__(self): ...
    def __comment_property__(self): ...
    def __file_addr_property__(self): ...
    def __load_adrr_property__(self): ...
    mnemonic: Incomplete
    operands: Incomplete
    comment: Incomplete
    addr: Incomplete
    size: Incomplete
    is_branch: Incomplete

class SBInstructionList:
    """
    Represents a list of machine instructions.  SBFunction and SBSymbol have
    GetInstructions() methods which return SBInstructionList instances.

    SBInstructionList supports instruction (:py:class:`SBInstruction` instance) iteration.
    For example (see also :py:class:`SBDebugger` for a more complete example), ::

        def disassemble_instructions (insts):
            for i in insts:
                print i

    defines a function which takes an SBInstructionList instance and prints out
    the machine instructions in assembly format.
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBInstructionList self) -> SBInstructionList
        __init__(SBInstructionList self, SBInstructionList rhs) -> SBInstructionList
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBInstructionList self) -> bool"""
    def GetSize(self):
        """GetSize(SBInstructionList self) -> size_t"""
    def GetInstructionAtIndex(self, idx):
        """GetInstructionAtIndex(SBInstructionList self, uint32_t idx) -> SBInstruction"""
    def GetInstructionsCount(self, start, end, canSetBreakpoint: bool = False):
        """GetInstructionsCount(SBInstructionList self, SBAddress start, SBAddress end, bool canSetBreakpoint=False) -> size_t"""
    def Clear(self):
        """Clear(SBInstructionList self)"""
    def AppendInstruction(self, inst):
        """AppendInstruction(SBInstructionList self, SBInstruction inst)"""
    def Print(self, *args):
        """
        Print(SBInstructionList self, SBFile out)
        Print(SBInstructionList self, lldb::FileSP BORROWED)
        """
    def GetDescription(self, description):
        """GetDescription(SBInstructionList self, SBStream description) -> bool"""
    def DumpEmulationForAllInstructions(self, triple):
        """DumpEmulationForAllInstructions(SBInstructionList self, char const * triple) -> bool"""
    def __iter__(self):
        """Iterate over all instructions in a lldb.SBInstructionList
        object."""
    def __len__(self) -> int:
        """Access len of the instruction list."""
    def __getitem__(self, key):
        """Access instructions by integer index for array access or by lldb.SBAddress to find an instruction that matches a section offset address object."""

class SBLanguageRuntime:
    """Utility functions for :ref:`LanguageType`"""
    thisown: Incomplete
    @staticmethod
    def GetLanguageTypeFromString(string):
        """GetLanguageTypeFromString(char const * string) -> lldb::LanguageType"""
    @staticmethod
    def GetNameForLanguageType(language):
        """GetNameForLanguageType(lldb::LanguageType language) -> char const *"""
    def __init__(self) -> None:
        """__init__(SBLanguageRuntime self) -> SBLanguageRuntime"""
    __swig_destroy__: Incomplete

class SBLaunchInfo:
    """Describes how a target or program should be launched."""
    thisown: Incomplete
    def __init__(self, argv) -> None:
        """__init__(SBLaunchInfo self, char const ** argv) -> SBLaunchInfo"""
    __swig_destroy__: Incomplete
    def GetProcessID(self):
        """GetProcessID(SBLaunchInfo self) -> lldb::pid_t"""
    def GetUserID(self):
        """GetUserID(SBLaunchInfo self) -> uint32_t"""
    def GetGroupID(self):
        """GetGroupID(SBLaunchInfo self) -> uint32_t"""
    def UserIDIsValid(self):
        """UserIDIsValid(SBLaunchInfo self) -> bool"""
    def GroupIDIsValid(self):
        """GroupIDIsValid(SBLaunchInfo self) -> bool"""
    def SetUserID(self, uid):
        """SetUserID(SBLaunchInfo self, uint32_t uid)"""
    def SetGroupID(self, gid):
        """SetGroupID(SBLaunchInfo self, uint32_t gid)"""
    def GetExecutableFile(self):
        """GetExecutableFile(SBLaunchInfo self) -> SBFileSpec"""
    def SetExecutableFile(self, exe_file, add_as_first_arg):
        """SetExecutableFile(SBLaunchInfo self, SBFileSpec exe_file, bool add_as_first_arg)"""
    def GetListener(self):
        """GetListener(SBLaunchInfo self) -> SBListener"""
    def SetListener(self, listener):
        """SetListener(SBLaunchInfo self, SBListener listener)"""
    def GetShadowListener(self):
        """GetShadowListener(SBLaunchInfo self) -> SBListener"""
    def SetShadowListener(self, listener):
        """SetShadowListener(SBLaunchInfo self, SBListener listener)"""
    def GetNumArguments(self):
        """GetNumArguments(SBLaunchInfo self) -> uint32_t"""
    def GetArgumentAtIndex(self, idx):
        """GetArgumentAtIndex(SBLaunchInfo self, uint32_t idx) -> char const *"""
    def SetArguments(self, argv, append):
        """SetArguments(SBLaunchInfo self, char const ** argv, bool append)"""
    def GetNumEnvironmentEntries(self):
        """GetNumEnvironmentEntries(SBLaunchInfo self) -> uint32_t"""
    def GetEnvironmentEntryAtIndex(self, idx):
        """GetEnvironmentEntryAtIndex(SBLaunchInfo self, uint32_t idx) -> char const *"""
    def SetEnvironmentEntries(self, envp, append):
        """SetEnvironmentEntries(SBLaunchInfo self, char const ** envp, bool append)"""
    def SetEnvironment(self, env, append):
        """SetEnvironment(SBLaunchInfo self, SBEnvironment env, bool append)"""
    def GetEnvironment(self):
        """GetEnvironment(SBLaunchInfo self) -> SBEnvironment"""
    def Clear(self):
        """Clear(SBLaunchInfo self)"""
    def GetWorkingDirectory(self):
        """GetWorkingDirectory(SBLaunchInfo self) -> char const *"""
    def SetWorkingDirectory(self, working_dir):
        """SetWorkingDirectory(SBLaunchInfo self, char const * working_dir)"""
    def GetLaunchFlags(self):
        """GetLaunchFlags(SBLaunchInfo self) -> uint32_t"""
    def SetLaunchFlags(self, flags):
        """SetLaunchFlags(SBLaunchInfo self, uint32_t flags)"""
    def GetProcessPluginName(self):
        """GetProcessPluginName(SBLaunchInfo self) -> char const *"""
    def SetProcessPluginName(self, plugin_name):
        """SetProcessPluginName(SBLaunchInfo self, char const * plugin_name)"""
    def GetShell(self):
        """GetShell(SBLaunchInfo self) -> char const *"""
    def SetShell(self, path):
        """SetShell(SBLaunchInfo self, char const * path)"""
    def GetShellExpandArguments(self):
        """GetShellExpandArguments(SBLaunchInfo self) -> bool"""
    def SetShellExpandArguments(self, expand):
        """SetShellExpandArguments(SBLaunchInfo self, bool expand)"""
    def GetResumeCount(self):
        """GetResumeCount(SBLaunchInfo self) -> uint32_t"""
    def SetResumeCount(self, c):
        """SetResumeCount(SBLaunchInfo self, uint32_t c)"""
    def AddCloseFileAction(self, fd):
        """AddCloseFileAction(SBLaunchInfo self, int fd) -> bool"""
    def AddDuplicateFileAction(self, fd, dup_fd):
        """AddDuplicateFileAction(SBLaunchInfo self, int fd, int dup_fd) -> bool"""
    def AddOpenFileAction(self, fd, path, read, write):
        """AddOpenFileAction(SBLaunchInfo self, int fd, char const * path, bool read, bool write) -> bool"""
    def AddSuppressFileAction(self, fd, read, write):
        """AddSuppressFileAction(SBLaunchInfo self, int fd, bool read, bool write) -> bool"""
    def SetLaunchEventData(self, data):
        """SetLaunchEventData(SBLaunchInfo self, char const * data)"""
    def GetLaunchEventData(self):
        """GetLaunchEventData(SBLaunchInfo self) -> char const *"""
    def GetDetachOnError(self):
        """GetDetachOnError(SBLaunchInfo self) -> bool"""
    def SetDetachOnError(self, enable):
        """SetDetachOnError(SBLaunchInfo self, bool enable)"""
    def GetScriptedProcessClassName(self):
        """GetScriptedProcessClassName(SBLaunchInfo self) -> char const *"""
    def SetScriptedProcessClassName(self, class_name):
        """SetScriptedProcessClassName(SBLaunchInfo self, char const * class_name)"""
    def GetScriptedProcessDictionary(self):
        """GetScriptedProcessDictionary(SBLaunchInfo self) -> SBStructuredData"""
    def SetScriptedProcessDictionary(self, dict):
        """SetScriptedProcessDictionary(SBLaunchInfo self, SBStructuredData dict)"""

class SBLineEntry:
    """
    Specifies an association with a contiguous range of instructions and
    a source file location.

    :py:class:`SBCompileUnit` contains SBLineEntry(s). For example, ::

        for lineEntry in compileUnit:
            print('line entry: %s:%d' % (str(lineEntry.GetFileSpec()),
                                        lineEntry.GetLine()))
            print('start addr: %s' % str(lineEntry.GetStartAddress()))
            print('end   addr: %s' % str(lineEntry.GetEndAddress()))

    produces: ::

        line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:20
        start addr: a.out[0x100000d98]
        end   addr: a.out[0x100000da3]
        line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:21
        start addr: a.out[0x100000da3]
        end   addr: a.out[0x100000da9]
        line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:22
        start addr: a.out[0x100000da9]
        end   addr: a.out[0x100000db6]
        line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:23
        start addr: a.out[0x100000db6]
        end   addr: a.out[0x100000dbc]
        ...

    See also :py:class:`SBCompileUnit` .
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBLineEntry self) -> SBLineEntry
        __init__(SBLineEntry self, SBLineEntry rhs) -> SBLineEntry
        """
    __swig_destroy__: Incomplete
    def GetStartAddress(self):
        """GetStartAddress(SBLineEntry self) -> SBAddress"""
    def GetEndAddress(self):
        """GetEndAddress(SBLineEntry self) -> SBAddress"""
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBLineEntry self) -> bool"""
    def GetFileSpec(self):
        """GetFileSpec(SBLineEntry self) -> SBFileSpec"""
    def GetLine(self):
        """GetLine(SBLineEntry self) -> uint32_t"""
    def GetColumn(self):
        """GetColumn(SBLineEntry self) -> uint32_t"""
    def SetFileSpec(self, filespec):
        """SetFileSpec(SBLineEntry self, SBFileSpec filespec)"""
    def SetLine(self, line):
        """SetLine(SBLineEntry self, uint32_t line)"""
    def SetColumn(self, column):
        """SetColumn(SBLineEntry self, uint32_t column)"""
    def __eq__(self, rhs):
        """__eq__(SBLineEntry self, SBLineEntry rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBLineEntry self, SBLineEntry rhs) -> bool"""
    def GetDescription(self, description):
        """GetDescription(SBLineEntry self, SBStream description) -> bool"""
    def __eq__(self, other): ...
    def __int__(self) -> int: ...
    def __hex__(self): ...
    file: Incomplete
    line: Incomplete
    column: Incomplete
    addr: Incomplete
    end_addr: Incomplete
    def __eq__(self, rhs): ...
    def __ne__(self, rhs): ...

class SBListener:
    """
    API clients can register its own listener to debugger events.

    See also :py:class:`SBEvent` for example usage of creating and adding a listener.
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBListener self) -> SBListener
        __init__(SBListener self, char const * name) -> SBListener
        __init__(SBListener self, SBListener rhs) -> SBListener
        """
    __swig_destroy__: Incomplete
    def AddEvent(self, event):
        """AddEvent(SBListener self, SBEvent event)"""
    def Clear(self):
        """Clear(SBListener self)"""
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBListener self) -> bool"""
    def StartListeningForEventClass(self, debugger, broadcaster_class, event_mask):
        """StartListeningForEventClass(SBListener self, SBDebugger debugger, char const * broadcaster_class, uint32_t event_mask) -> uint32_t"""
    def StopListeningForEventClass(self, debugger, broadcaster_class, event_mask):
        """StopListeningForEventClass(SBListener self, SBDebugger debugger, char const * broadcaster_class, uint32_t event_mask) -> bool"""
    def StartListeningForEvents(self, broadcaster, event_mask):
        """StartListeningForEvents(SBListener self, SBBroadcaster broadcaster, uint32_t event_mask) -> uint32_t"""
    def StopListeningForEvents(self, broadcaster, event_mask):
        """StopListeningForEvents(SBListener self, SBBroadcaster broadcaster, uint32_t event_mask) -> bool"""
    def WaitForEvent(self, num_seconds, event):
        """WaitForEvent(SBListener self, uint32_t num_seconds, SBEvent event) -> bool"""
    def WaitForEventForBroadcaster(self, num_seconds, broadcaster, sb_event):
        """WaitForEventForBroadcaster(SBListener self, uint32_t num_seconds, SBBroadcaster broadcaster, SBEvent sb_event) -> bool"""
    def WaitForEventForBroadcasterWithType(self, num_seconds, broadcaster, event_type_mask, sb_event):
        """WaitForEventForBroadcasterWithType(SBListener self, uint32_t num_seconds, SBBroadcaster broadcaster, uint32_t event_type_mask, SBEvent sb_event) -> bool"""
    def PeekAtNextEvent(self, sb_event):
        """PeekAtNextEvent(SBListener self, SBEvent sb_event) -> bool"""
    def PeekAtNextEventForBroadcaster(self, broadcaster, sb_event):
        """PeekAtNextEventForBroadcaster(SBListener self, SBBroadcaster broadcaster, SBEvent sb_event) -> bool"""
    def PeekAtNextEventForBroadcasterWithType(self, broadcaster, event_type_mask, sb_event):
        """PeekAtNextEventForBroadcasterWithType(SBListener self, SBBroadcaster broadcaster, uint32_t event_type_mask, SBEvent sb_event) -> bool"""
    def GetNextEvent(self, sb_event):
        """GetNextEvent(SBListener self, SBEvent sb_event) -> bool"""
    def GetNextEventForBroadcaster(self, broadcaster, sb_event):
        """GetNextEventForBroadcaster(SBListener self, SBBroadcaster broadcaster, SBEvent sb_event) -> bool"""
    def GetNextEventForBroadcasterWithType(self, broadcaster, event_type_mask, sb_event):
        """GetNextEventForBroadcasterWithType(SBListener self, SBBroadcaster broadcaster, uint32_t event_type_mask, SBEvent sb_event) -> bool"""
    def HandleBroadcastEvent(self, event):
        """HandleBroadcastEvent(SBListener self, SBEvent event) -> bool"""

class SBMemoryRegionInfo:
    """API clients can get information about memory regions in processes."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBMemoryRegionInfo self) -> SBMemoryRegionInfo
        __init__(SBMemoryRegionInfo self, SBMemoryRegionInfo rhs) -> SBMemoryRegionInfo
        __init__(SBMemoryRegionInfo self, char const * name, lldb::addr_t begin, lldb::addr_t end, uint32_t permissions, bool mapped, bool stack_memory=False) -> SBMemoryRegionInfo
        """
    __swig_destroy__: Incomplete
    def Clear(self):
        """Clear(SBMemoryRegionInfo self)"""
    def GetRegionBase(self):
        """GetRegionBase(SBMemoryRegionInfo self) -> lldb::addr_t"""
    def GetRegionEnd(self):
        """GetRegionEnd(SBMemoryRegionInfo self) -> lldb::addr_t"""
    def IsReadable(self):
        """IsReadable(SBMemoryRegionInfo self) -> bool"""
    def IsWritable(self):
        """IsWritable(SBMemoryRegionInfo self) -> bool"""
    def IsExecutable(self):
        """IsExecutable(SBMemoryRegionInfo self) -> bool"""
    def IsMapped(self):
        """IsMapped(SBMemoryRegionInfo self) -> bool"""
    def GetName(self):
        """GetName(SBMemoryRegionInfo self) -> char const *"""
    def HasDirtyMemoryPageList(self):
        '''

        GetRegionEnd(SBMemoryRegionInfo self) -> lldb::addr_t
        Returns whether this memory region has a list of modified (dirty)
        pages available or not.  When calling GetNumDirtyPages(), you will
        have 0 returned for both "dirty page list is not known" and 
        "empty dirty page list" (that is, no modified pages in this
        memory region).  You must use this method to disambiguate.
        '''
    def GetNumDirtyPages(self):
        """

        GetNumDirtyPages(SBMemoryRegionInfo self) -> uint32_t
        Return the number of dirty (modified) memory pages in this
        memory region, if available.  You must use the 
        SBMemoryRegionInfo::HasDirtyMemoryPageList() method to
        determine if a dirty memory list is available; it will depend
        on the target system can provide this information.
        """
    def GetDirtyPageAddressAtIndex(self, idx):
        """

        GetDirtyPageAddressAtIndex(SBMemoryRegionInfo self, uint32_t idx) -> lldb::addr_t
        Return the address of a modified, or dirty, page of memory.
        If the provided index is out of range, or this memory region 
        does not have dirty page information, LLDB_INVALID_ADDRESS 
        is returned.
        """
    def GetPageSize(self):
        """

        GetPageSize(SBMemoryRegionInfo self) -> int
        Return the size of pages in this memory region.  0 will be returned
        if this information was unavailable.
        """
    def __eq__(self, rhs):
        """__eq__(SBMemoryRegionInfo self, SBMemoryRegionInfo rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBMemoryRegionInfo self, SBMemoryRegionInfo rhs) -> bool"""
    def GetDescription(self, description):
        """GetDescription(SBMemoryRegionInfo self, SBStream description) -> bool"""
    def __eq__(self, other): ...
    def __hex__(self): ...
    def __len__(self) -> int: ...

class SBMemoryRegionInfoList:
    """Represents a list of :py:class:`SBMemoryRegionInfo`."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBMemoryRegionInfoList self) -> SBMemoryRegionInfoList
        __init__(SBMemoryRegionInfoList self, SBMemoryRegionInfoList rhs) -> SBMemoryRegionInfoList
        """
    __swig_destroy__: Incomplete
    def GetSize(self):
        """GetSize(SBMemoryRegionInfoList self) -> uint32_t"""
    def GetMemoryRegionContainingAddress(self, addr, region_info):
        """GetMemoryRegionContainingAddress(SBMemoryRegionInfoList self, lldb::addr_t addr, SBMemoryRegionInfo region_info) -> bool"""
    def GetMemoryRegionAtIndex(self, idx, region_info):
        """GetMemoryRegionAtIndex(SBMemoryRegionInfoList self, uint32_t idx, SBMemoryRegionInfo region_info) -> bool"""
    def Append(self, *args):
        """
        Append(SBMemoryRegionInfoList self, SBMemoryRegionInfo region)
        Append(SBMemoryRegionInfoList self, SBMemoryRegionInfoList region_list)
        """
    def Clear(self):
        """Clear(SBMemoryRegionInfoList self)"""
    def __len__(self) -> int:
        """Return the number of memory region info in a lldb.SBMemoryRegionInfoList object."""
    def __iter__(self):
        """Iterate over all the memory regions in a lldb.SBMemoryRegionInfoList object."""

class SBModule:
    """
    Represents an executable image and its associated object and symbol files.

    The module is designed to be able to select a single slice of an
    executable image as it would appear on disk and during program
    execution.

    You can retrieve SBModule from :py:class:`SBSymbolContext` , which in turn is available
    from SBFrame.

    SBModule supports symbol iteration, for example, ::

        for symbol in module:
            name = symbol.GetName()
            saddr = symbol.GetStartAddress()
            eaddr = symbol.GetEndAddress()

    and rich comparison methods which allow the API program to use, ::

        if thisModule == thatModule:
            print('This module is the same as that module')

    to test module equality.  A module also contains object file sections, namely
    :py:class:`SBSection` .  SBModule supports section iteration through section_iter(), for
    example, ::

        print('Number of sections: %d' % module.GetNumSections())
        for sec in module.section_iter():
            print(sec)

    And to iterate the symbols within a SBSection, use symbol_in_section_iter(), ::

        # Iterates the text section and prints each symbols within each sub-section.
        for subsec in text_sec:
            print(INDENT + repr(subsec))
            for sym in exe_module.symbol_in_section_iter(subsec):
                print(INDENT2 + repr(sym))
                print(INDENT2 + 'symbol type: %s' % symbol_type_to_str(sym.GetType()))

    produces this following output: ::

        [0x0000000100001780-0x0000000100001d5c) a.out.__TEXT.__text
            id = {0x00000004}, name = 'mask_access(MaskAction, unsigned int)', range = [0x00000001000017c0-0x0000000100001870)
            symbol type: code
            id = {0x00000008}, name = 'thread_func(void*)', range = [0x0000000100001870-0x00000001000019b0)
            symbol type: code
            id = {0x0000000c}, name = 'main', range = [0x00000001000019b0-0x0000000100001d5c)
            symbol type: code
            id = {0x00000023}, name = 'start', address = 0x0000000100001780
            symbol type: code
        [0x0000000100001d5c-0x0000000100001da4) a.out.__TEXT.__stubs
            id = {0x00000024}, name = '__stack_chk_fail', range = [0x0000000100001d5c-0x0000000100001d62)
            symbol type: trampoline
            id = {0x00000028}, name = 'exit', range = [0x0000000100001d62-0x0000000100001d68)
            symbol type: trampoline
            id = {0x00000029}, name = 'fflush', range = [0x0000000100001d68-0x0000000100001d6e)
            symbol type: trampoline
            id = {0x0000002a}, name = 'fgets', range = [0x0000000100001d6e-0x0000000100001d74)
            symbol type: trampoline
            id = {0x0000002b}, name = 'printf', range = [0x0000000100001d74-0x0000000100001d7a)
            symbol type: trampoline
            id = {0x0000002c}, name = 'pthread_create', range = [0x0000000100001d7a-0x0000000100001d80)
            symbol type: trampoline
            id = {0x0000002d}, name = 'pthread_join', range = [0x0000000100001d80-0x0000000100001d86)
            symbol type: trampoline
            id = {0x0000002e}, name = 'pthread_mutex_lock', range = [0x0000000100001d86-0x0000000100001d8c)
            symbol type: trampoline
            id = {0x0000002f}, name = 'pthread_mutex_unlock', range = [0x0000000100001d8c-0x0000000100001d92)
            symbol type: trampoline
            id = {0x00000030}, name = 'rand', range = [0x0000000100001d92-0x0000000100001d98)
            symbol type: trampoline
            id = {0x00000031}, name = 'strtoul', range = [0x0000000100001d98-0x0000000100001d9e)
            symbol type: trampoline
            id = {0x00000032}, name = 'usleep', range = [0x0000000100001d9e-0x0000000100001da4)
            symbol type: trampoline
        [0x0000000100001da4-0x0000000100001e2c) a.out.__TEXT.__stub_helper
        [0x0000000100001e2c-0x0000000100001f10) a.out.__TEXT.__cstring
        [0x0000000100001f10-0x0000000100001f68) a.out.__TEXT.__unwind_info
        [0x0000000100001f68-0x0000000100001ff8) a.out.__TEXT.__eh_frame

    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBModule self) -> SBModule
        __init__(SBModule self, SBModule rhs) -> SBModule
        __init__(SBModule self, SBModuleSpec module_spec) -> SBModule
        __init__(SBModule self, SBProcess process, lldb::addr_t header_addr) -> SBModule
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBModule self) -> bool"""
    def Clear(self):
        """Clear(SBModule self)"""
    def IsFileBacked(self):
        """
        IsFileBacked(SBModule self) -> bool

            Check if the module is file backed.

            @return

                True, if the module is backed by an object file on disk.
                False, if the module is backed by an object file in memory.
        """
    def GetFileSpec(self):
        """
        GetFileSpec(SBModule self) -> SBFileSpec

            Get const accessor for the module file specification.

            This function returns the file for the module on the host system
            that is running LLDB. This can differ from the path on the
            platform since we might be doing remote debugging.

            @return
                A const reference to the file specification object.
        """
    def GetPlatformFileSpec(self):
        """
        GetPlatformFileSpec(SBModule self) -> SBFileSpec

            Get accessor for the module platform file specification.

            Platform file refers to the path of the module as it is known on
            the remote system on which it is being debugged. For local
            debugging this is always the same as Module::GetFileSpec(). But
            remote debugging might mention a file '/usr/lib/liba.dylib'
            which might be locally downloaded and cached. In this case the
            platform file could be something like:
            '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib'
            The file could also be cached in a local developer kit directory.

            @return
                A const reference to the file specification object.
        """
    def SetPlatformFileSpec(self, platform_file):
        """SetPlatformFileSpec(SBModule self, SBFileSpec platform_file) -> bool"""
    def GetRemoteInstallFileSpec(self):
        """GetRemoteInstallFileSpec(SBModule self) -> SBFileSpec"""
    def SetRemoteInstallFileSpec(self, file):
        """SetRemoteInstallFileSpec(SBModule self, SBFileSpec file) -> bool"""
    def GetByteOrder(self):
        """GetByteOrder(SBModule self) -> lldb::ByteOrder"""
    def GetAddressByteSize(self):
        """GetAddressByteSize(SBModule self) -> uint32_t"""
    def GetTriple(self):
        """GetTriple(SBModule self) -> char const *"""
    def GetUUIDBytes(self):
        """GetUUIDBytes(SBModule self) -> uint8_t const *"""
    def GetUUIDString(self):
        """
        GetUUIDString(SBModule self) -> char const *
        Returns the UUID of the module as a Python string.
        """
    def __eq__(self, rhs):
        """__eq__(SBModule self, SBModule rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBModule self, SBModule rhs) -> bool"""
    def FindSection(self, sect_name):
        """FindSection(SBModule self, char const * sect_name) -> SBSection"""
    def ResolveFileAddress(self, vm_addr):
        """ResolveFileAddress(SBModule self, lldb::addr_t vm_addr) -> SBAddress"""
    def ResolveSymbolContextForAddress(self, addr, resolve_scope):
        """ResolveSymbolContextForAddress(SBModule self, SBAddress addr, uint32_t resolve_scope) -> SBSymbolContext"""
    def GetDescription(self, description):
        """GetDescription(SBModule self, SBStream description) -> bool"""
    def GetNumCompileUnits(self):
        """GetNumCompileUnits(SBModule self) -> uint32_t"""
    def GetCompileUnitAtIndex(self, arg2):
        """GetCompileUnitAtIndex(SBModule self, uint32_t arg2) -> SBCompileUnit"""
    def FindCompileUnits(self, sb_file_spec):
        """
        FindCompileUnits(SBModule self, SBFileSpec sb_file_spec) -> SBSymbolContextList

            Find compile units related to this module and passed source
            file.

            @param[in] sb_file_spec
                A :py:class:`SBFileSpec` object that contains source file
                specification.

            @return
                A :py:class:`SBSymbolContextList` that gets filled in with all of
                the symbol contexts for all the matches.
        """
    def GetNumSymbols(self):
        """GetNumSymbols(SBModule self) -> size_t"""
    def GetSymbolAtIndex(self, idx):
        """GetSymbolAtIndex(SBModule self, size_t idx) -> SBSymbol"""
    def FindSymbol(self, *args):
        """FindSymbol(SBModule self, char const * name, lldb::SymbolType type=eSymbolTypeAny) -> SBSymbol"""
    def FindSymbols(self, *args):
        """FindSymbols(SBModule self, char const * name, lldb::SymbolType type=eSymbolTypeAny) -> SBSymbolContextList"""
    def GetNumSections(self):
        """GetNumSections(SBModule self) -> size_t"""
    def GetSectionAtIndex(self, idx):
        """GetSectionAtIndex(SBModule self, size_t idx) -> SBSection"""
    def FindFunctions(self, *args):
        """
        FindFunctions(SBModule self, char const * name, uint32_t name_type_mask=eFunctionNameTypeAny) -> SBSymbolContextList

            Find functions by name.

            @param[in] name
                The name of the function we are looking for.

            @param[in] name_type_mask
                A logical OR of one or more FunctionNameType enum bits that
                indicate what kind of names should be used when doing the
                lookup. Bits include fully qualified names, base names,
                C++ methods, or ObjC selectors.
                See FunctionNameType for more details.

            @return
                A symbol context list that gets filled in with all of the
                matches.
        """
    def FindGlobalVariables(self, target, name, max_matches):
        """
        FindGlobalVariables(SBModule self, SBTarget target, char const * name, uint32_t max_matches) -> SBValueList

            Find global and static variables by name.

            @param[in] target
                A valid SBTarget instance representing the debuggee.

            @param[in] name
                The name of the global or static variable we are looking
                for.

            @param[in] max_matches
                Allow the number of matches to be limited to max_matches.

            @return
                A list of matched variables in an SBValueList.
        """
    def FindFirstGlobalVariable(self, target, name):
        """
        FindFirstGlobalVariable(SBModule self, SBTarget target, char const * name) -> SBValue

            Find the first global (or static) variable by name.

            @param[in] target
                A valid SBTarget instance representing the debuggee.

            @param[in] name
                The name of the global or static variable we are looking
                for.

            @return
                An SBValue that gets filled in with the found variable (if any).
        """
    def FindFirstType(self, name):
        """FindFirstType(SBModule self, char const * name) -> SBType"""
    def FindTypes(self, type):
        """FindTypes(SBModule self, char const * type) -> SBTypeList"""
    def GetTypeByID(self, uid):
        """GetTypeByID(SBModule self, lldb::user_id_t uid) -> SBType"""
    def GetBasicType(self, type):
        """GetBasicType(SBModule self, lldb::BasicType type) -> SBType"""
    def GetTypes(self, *args):
        """
        GetTypes(SBModule self, uint32_t type_mask=eTypeClassAny) -> SBTypeList

            Get all types matching type_mask from debug info in this
            module.

            @param[in] type_mask
                A bitfield that consists of one or more bits logically OR'ed
                together from the lldb::TypeClass enumeration. This allows
                you to request only structure types, or only class, struct
                and union types. Passing in lldb::eTypeClassAny will return
                all types found in the debug information for this module.

            @return
                A list of types in this module that match type_mask
        """
    def GetVersion(self):
        """GetVersion(SBModule self) -> uint32_t"""
    def GetSymbolFileSpec(self):
        """GetSymbolFileSpec(SBModule self) -> SBFileSpec"""
    def GetObjectFileHeaderAddress(self):
        """GetObjectFileHeaderAddress(SBModule self) -> SBAddress"""
    def GetObjectFileEntryPointAddress(self):
        """GetObjectFileEntryPointAddress(SBModule self) -> SBAddress"""
    @staticmethod
    def GetNumberAllocatedModules():
        """
        GetNumberAllocatedModules() -> uint32_t

            Returns the number of modules in the module cache. This is an
            implementation detail exposed for testing and should not be relied upon.

            @return
                The number of modules in the module cache.
        """
    @staticmethod
    def GarbageCollectAllocatedModules():
        """
        GarbageCollectAllocatedModules()

            Removes all modules which are no longer needed by any part of LLDB from
            the module cache.

            This is an implementation detail exposed for testing and should not be
            relied upon. Use SBDebugger::MemoryPressureDetected instead to reduce
            LLDB's memory consumption during execution.

        """
    def __eq__(self, other): ...
    def __len__(self) -> int:
        """Return the number of symbols in a lldb.SBModule object."""
    def __iter__(self):
        """Iterate over all symbols in a lldb.SBModule object."""
    def section_iter(self):
        """Iterate over all sections in a lldb.SBModule object."""
    def compile_unit_iter(self):
        """Iterate over all compile units in a lldb.SBModule object."""
    def symbol_in_section_iter(self, section) -> Generator[Incomplete]:
        """Given a module and its contained section, returns an iterator on the
        symbols within the section."""
    class symbols_access:
        re_compile_type: Incomplete
        sbmodule: Incomplete
        def __init__(self, sbmodule) -> None: ...
        def __len__(self) -> int: ...
        def __getitem__(self, key): ...
    def get_symbols_access_object(self):
        """An accessor function that returns a symbols_access() object which allows lazy symbol access from a lldb.SBModule object."""
    def get_compile_units_access_object(self):
        """An accessor function that returns a compile_units_access() object which allows lazy compile unit access from a lldb.SBModule object."""
    def get_symbols_array(self):
        """An accessor function that returns a list() that contains all symbols in a lldb.SBModule object."""
    class sections_access:
        re_compile_type: Incomplete
        sbmodule: Incomplete
        def __init__(self, sbmodule) -> None: ...
        def __len__(self) -> int: ...
        def __getitem__(self, key): ...
    class compile_units_access:
        re_compile_type: Incomplete
        sbmodule: Incomplete
        def __init__(self, sbmodule) -> None: ...
        def __len__(self) -> int: ...
        def __getitem__(self, key): ...
    def get_sections_access_object(self):
        """An accessor function that returns a sections_access() object which allows lazy section array access."""
    sections_array: Incomplete
    def get_sections_array(self):
        """An accessor function that returns an array object that contains all sections in this module object."""
    compile_units_array: Incomplete
    def get_compile_units_array(self):
        """An accessor function that returns an array object that contains all compile_units in this module object."""
    symbols: Incomplete
    symbol: Incomplete
    sections: Incomplete
    compile_units: Incomplete
    section: Incomplete
    def get_uuid(self): ...
    uuid: Incomplete
    file: Incomplete
    platform_file: Incomplete
    byte_order: Incomplete
    addr_size: Incomplete
    triple: Incomplete
    num_symbols: Incomplete
    num_sections: Incomplete
    def __eq__(self, rhs): ...
    def __ne__(self, rhs): ...

class SBModuleSpec:
    """Proxy of C++ lldb::SBModuleSpec class."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBModuleSpec self) -> SBModuleSpec
        __init__(SBModuleSpec self, SBModuleSpec rhs) -> SBModuleSpec
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBModuleSpec self) -> bool"""
    def Clear(self):
        """Clear(SBModuleSpec self)"""
    def GetFileSpec(self):
        """
        GetFileSpec(SBModuleSpec self) -> SBFileSpec

            Get const accessor for the module file.

            This function returns the file for the module on the host system
            that is running LLDB. This can differ from the path on the
            platform since we might be doing remote debugging.

            @return
                A const reference to the file specification object.
        """
    def SetFileSpec(self, fspec):
        """SetFileSpec(SBModuleSpec self, SBFileSpec fspec)"""
    def GetPlatformFileSpec(self):
        """
        GetPlatformFileSpec(SBModuleSpec self) -> SBFileSpec

            Get accessor for the module platform file.

            Platform file refers to the path of the module as it is known on
            the remote system on which it is being debugged. For local
            debugging this is always the same as Module::GetFileSpec(). But
            remote debugging might mention a file '/usr/lib/liba.dylib'
            which might be locally downloaded and cached. In this case the
            platform file could be something like:
            '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib'
            The file could also be cached in a local developer kit directory.

            @return
                A const reference to the file specification object.
        """
    def SetPlatformFileSpec(self, fspec):
        """SetPlatformFileSpec(SBModuleSpec self, SBFileSpec fspec)"""
    def GetSymbolFileSpec(self):
        """GetSymbolFileSpec(SBModuleSpec self) -> SBFileSpec"""
    def SetSymbolFileSpec(self, fspec):
        """SetSymbolFileSpec(SBModuleSpec self, SBFileSpec fspec)"""
    def GetObjectName(self):
        """GetObjectName(SBModuleSpec self) -> char const *"""
    def SetObjectName(self, name):
        """SetObjectName(SBModuleSpec self, char const * name)"""
    def GetTriple(self):
        """GetTriple(SBModuleSpec self) -> char const *"""
    def SetTriple(self, triple):
        """SetTriple(SBModuleSpec self, char const * triple)"""
    def GetUUIDBytes(self):
        """GetUUIDBytes(SBModuleSpec self) -> uint8_t const *"""
    def GetUUIDLength(self):
        """GetUUIDLength(SBModuleSpec self) -> size_t"""
    def SetUUIDBytes(self, uuid, uuid_len):
        """SetUUIDBytes(SBModuleSpec self, uint8_t const * uuid, size_t uuid_len) -> bool"""
    def GetObjectOffset(self):
        """GetObjectOffset(SBModuleSpec self) -> uint64_t"""
    def SetObjectOffset(self, object_offset):
        """SetObjectOffset(SBModuleSpec self, uint64_t object_offset)"""
    def GetObjectSize(self):
        """GetObjectSize(SBModuleSpec self) -> uint64_t"""
    def SetObjectSize(self, object_size):
        """SetObjectSize(SBModuleSpec self, uint64_t object_size)"""
    def GetDescription(self, description):
        """GetDescription(SBModuleSpec self, SBStream description) -> bool"""

class SBModuleSpecList:
    """Represents a list of :py:class:`SBModuleSpec`."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBModuleSpecList self) -> SBModuleSpecList
        __init__(SBModuleSpecList self, SBModuleSpecList rhs) -> SBModuleSpecList
        """
    __swig_destroy__: Incomplete
    @staticmethod
    def GetModuleSpecifications(path):
        """GetModuleSpecifications(char const * path) -> SBModuleSpecList"""
    def Append(self, *args):
        """
        Append(SBModuleSpecList self, SBModuleSpec spec)
        Append(SBModuleSpecList self, SBModuleSpecList spec_list)
        """
    def FindFirstMatchingSpec(self, match_spec):
        """FindFirstMatchingSpec(SBModuleSpecList self, SBModuleSpec match_spec) -> SBModuleSpec"""
    def FindMatchingSpecs(self, match_spec):
        """FindMatchingSpecs(SBModuleSpecList self, SBModuleSpec match_spec) -> SBModuleSpecList"""
    def GetSize(self):
        """GetSize(SBModuleSpecList self) -> size_t"""
    def GetSpecAtIndex(self, i):
        """GetSpecAtIndex(SBModuleSpecList self, size_t i) -> SBModuleSpec"""
    def GetDescription(self, description):
        """GetDescription(SBModuleSpecList self, SBStream description) -> bool"""
    def __len__(self) -> int:
        """Return the number of ModuleSpec in a lldb.SBModuleSpecList object."""
    def __iter__(self):
        """Iterate over all ModuleSpecs in a lldb.SBModuleSpecList object."""

class SBPlatformConnectOptions:
    """Describes how :py:class:`SBPlatform.ConnectRemote` connects to a remote platform."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBPlatformConnectOptions self, char const * url) -> SBPlatformConnectOptions
        __init__(SBPlatformConnectOptions self, SBPlatformConnectOptions rhs) -> SBPlatformConnectOptions
        """
    __swig_destroy__: Incomplete
    def GetURL(self):
        """GetURL(SBPlatformConnectOptions self) -> char const *"""
    def SetURL(self, url):
        """SetURL(SBPlatformConnectOptions self, char const * url)"""
    def GetRsyncEnabled(self):
        """GetRsyncEnabled(SBPlatformConnectOptions self) -> bool"""
    def EnableRsync(self, options, remote_path_prefix, omit_remote_hostname):
        """EnableRsync(SBPlatformConnectOptions self, char const * options, char const * remote_path_prefix, bool omit_remote_hostname)"""
    def DisableRsync(self):
        """DisableRsync(SBPlatformConnectOptions self)"""
    def GetLocalCacheDirectory(self):
        """GetLocalCacheDirectory(SBPlatformConnectOptions self) -> char const *"""
    def SetLocalCacheDirectory(self, path):
        """SetLocalCacheDirectory(SBPlatformConnectOptions self, char const * path)"""

class SBPlatformShellCommand:
    """Represents a shell command that can be run by :py:class:`SBPlatform.Run`."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBPlatformShellCommand self, char const * shell, char const * shell_command) -> SBPlatformShellCommand
        __init__(SBPlatformShellCommand self, char const * shell_command) -> SBPlatformShellCommand
        __init__(SBPlatformShellCommand self, SBPlatformShellCommand rhs) -> SBPlatformShellCommand
        """
    __swig_destroy__: Incomplete
    def Clear(self):
        """Clear(SBPlatformShellCommand self)"""
    def GetShell(self):
        """GetShell(SBPlatformShellCommand self) -> char const *"""
    def SetShell(self, shell):
        """SetShell(SBPlatformShellCommand self, char const * shell)"""
    def GetCommand(self):
        """GetCommand(SBPlatformShellCommand self) -> char const *"""
    def SetCommand(self, shell_command):
        """SetCommand(SBPlatformShellCommand self, char const * shell_command)"""
    def GetWorkingDirectory(self):
        """GetWorkingDirectory(SBPlatformShellCommand self) -> char const *"""
    def SetWorkingDirectory(self, path):
        """SetWorkingDirectory(SBPlatformShellCommand self, char const * path)"""
    def GetTimeoutSeconds(self):
        """GetTimeoutSeconds(SBPlatformShellCommand self) -> uint32_t"""
    def SetTimeoutSeconds(self, sec):
        """SetTimeoutSeconds(SBPlatformShellCommand self, uint32_t sec)"""
    def GetSignal(self):
        """GetSignal(SBPlatformShellCommand self) -> int"""
    def GetStatus(self):
        """GetStatus(SBPlatformShellCommand self) -> int"""
    def GetOutput(self):
        """GetOutput(SBPlatformShellCommand self) -> char const *"""

class SBPlatform:
    """
    A class that represents a platform that can represent the current host or a remote host debug platform.

    The SBPlatform class represents the current host, or a remote host.
    It can be connected to a remote platform in order to provide ways
    to remotely launch and attach to processes, upload/download files,
    create directories, run remote shell commands, find locally cached
    versions of files from the remote system, and much more.

    SBPlatform objects can be created and then used to connect to a remote
    platform which allows the SBPlatform to be used to get a list of the
    current processes on the remote host, attach to one of those processes,
    install programs on the remote system, attach and launch processes,
    and much more.

    Every :py:class:`SBTarget` has a corresponding SBPlatform. The platform can be
    specified upon target creation, or the currently selected platform
    will attempt to be used when creating the target automatically as long
    as the currently selected platform matches the target architecture
    and executable type. If the architecture or executable type do not match,
    a suitable platform will be found automatically.
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBPlatform self) -> SBPlatform
        __init__(SBPlatform self, char const * platform_name) -> SBPlatform
        __init__(SBPlatform self, SBPlatform rhs) -> SBPlatform
        """
    __swig_destroy__: Incomplete
    @staticmethod
    def GetHostPlatform():
        """GetHostPlatform() -> SBPlatform"""
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBPlatform self) -> bool"""
    def Clear(self):
        """Clear(SBPlatform self)"""
    def GetWorkingDirectory(self):
        """GetWorkingDirectory(SBPlatform self) -> char const *"""
    def SetWorkingDirectory(self, path):
        """SetWorkingDirectory(SBPlatform self, char const * path) -> bool"""
    def GetName(self):
        """GetName(SBPlatform self) -> char const *"""
    def ConnectRemote(self, connect_options):
        """ConnectRemote(SBPlatform self, SBPlatformConnectOptions connect_options) -> SBError"""
    def DisconnectRemote(self):
        """DisconnectRemote(SBPlatform self)"""
    def IsConnected(self):
        """IsConnected(SBPlatform self) -> bool"""
    def GetTriple(self):
        """GetTriple(SBPlatform self) -> char const *"""
    def GetHostname(self):
        """GetHostname(SBPlatform self) -> char const *"""
    def GetOSBuild(self):
        """GetOSBuild(SBPlatform self) -> char const *"""
    def GetOSDescription(self):
        """GetOSDescription(SBPlatform self) -> char const *"""
    def GetOSMajorVersion(self):
        """GetOSMajorVersion(SBPlatform self) -> uint32_t"""
    def GetOSMinorVersion(self):
        """GetOSMinorVersion(SBPlatform self) -> uint32_t"""
    def GetOSUpdateVersion(self):
        """GetOSUpdateVersion(SBPlatform self) -> uint32_t"""
    def SetSDKRoot(self, sysroot):
        """SetSDKRoot(SBPlatform self, char const * sysroot)"""
    def Put(self, src, dst):
        """Put(SBPlatform self, SBFileSpec src, SBFileSpec dst) -> SBError"""
    def Get(self, src, dst):
        """Get(SBPlatform self, SBFileSpec src, SBFileSpec dst) -> SBError"""
    def Install(self, src, dst):
        """Install(SBPlatform self, SBFileSpec src, SBFileSpec dst) -> SBError"""
    def Run(self, shell_command):
        """Run(SBPlatform self, SBPlatformShellCommand shell_command) -> SBError"""
    def Launch(self, launch_info):
        """Launch(SBPlatform self, SBLaunchInfo launch_info) -> SBError"""
    def Attach(self, attach_info, debugger, target, error):
        """Attach(SBPlatform self, SBAttachInfo attach_info, SBDebugger debugger, SBTarget target, SBError error) -> SBProcess"""
    def GetAllProcesses(self, error):
        """GetAllProcesses(SBPlatform self, SBError error) -> SBProcessInfoList"""
    def Kill(self, pid):
        """Kill(SBPlatform self, lldb::pid_t const pid) -> SBError"""
    def MakeDirectory(self, *args):
        """MakeDirectory(SBPlatform self, char const * path, uint32_t file_permissions=eFilePermissionsDirectoryDefault) -> SBError"""
    def GetFilePermissions(self, path):
        """GetFilePermissions(SBPlatform self, char const * path) -> uint32_t"""
    def SetFilePermissions(self, path, file_permissions):
        """SetFilePermissions(SBPlatform self, char const * path, uint32_t file_permissions) -> SBError"""
    def GetUnixSignals(self):
        """GetUnixSignals(SBPlatform self) -> SBUnixSignals"""
    def GetEnvironment(self):
        """GetEnvironment(SBPlatform self) -> SBEnvironment"""
    def SetLocateModuleCallback(self, callback):
        """SetLocateModuleCallback(SBPlatform self, lldb::SBPlatformLocateModuleCallback callback) -> SBError"""

class SBProcess:
    """
    Represents the process associated with the target program.

    SBProcess supports thread iteration. For example (from test/lldbutil.py), ::

        # ==================================================
        # Utility functions related to Threads and Processes
        # ==================================================

        def get_stopped_threads(process, reason):
            '''Returns the thread(s) with the specified stop reason in a list.

            The list can be empty if no such thread exists.
            '''
            threads = []
            for t in process:
                if t.GetStopReason() == reason:
                    threads.append(t)
            return threads

    """
    thisown: Incomplete
    eBroadcastBitStateChanged: Incomplete
    eBroadcastBitInterrupt: Incomplete
    eBroadcastBitSTDOUT: Incomplete
    eBroadcastBitSTDERR: Incomplete
    eBroadcastBitProfileData: Incomplete
    eBroadcastBitStructuredData: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBProcess self) -> SBProcess
        __init__(SBProcess self, SBProcess rhs) -> SBProcess
        """
    __swig_destroy__: Incomplete
    @staticmethod
    def GetBroadcasterClassName():
        """GetBroadcasterClassName() -> char const *"""
    def GetPluginName(self):
        """GetPluginName(SBProcess self) -> char const *"""
    def GetShortPluginName(self):
        """GetShortPluginName(SBProcess self) -> char const *"""
    def Clear(self):
        """Clear(SBProcess self)"""
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBProcess self) -> bool"""
    def GetTarget(self):
        """GetTarget(SBProcess self) -> SBTarget"""
    def GetByteOrder(self):
        """GetByteOrder(SBProcess self) -> lldb::ByteOrder"""
    def PutSTDIN(self, src):
        """

        Writes data into the current process's stdin. API client specifies a Python
        string as the only argument.
        """
    def GetSTDOUT(self, dst):
        """

        Reads data from the current process's stdout stream. API client specifies
        the size of the buffer to read data into. It returns the byte buffer in a
        Python string.
        """
    def GetSTDERR(self, dst):
        """

        Reads data from the current process's stderr stream. API client specifies
        the size of the buffer to read data into. It returns the byte buffer in a
        Python string.
        """
    def GetAsyncProfileData(self, dst):
        """GetAsyncProfileData(SBProcess self, char * dst) -> size_t"""
    def ReportEventState(self, *args):
        """
        ReportEventState(SBProcess self, SBEvent event, SBFile file)
        ReportEventState(SBProcess self, SBEvent event, lldb::FileSP BORROWED)
        """
    def AppendEventStateReport(self, event, result):
        """AppendEventStateReport(SBProcess self, SBEvent event, SBCommandReturnObject result)"""
    def RemoteAttachToProcessWithID(self, pid, error):
        """
        RemoteAttachToProcessWithID(SBProcess self, lldb::pid_t pid, SBError error) -> bool

            Remote connection related functions. These will fail if the
            process is not in eStateConnected. They are intended for use
            when connecting to an externally managed debugserver instance.
        """
    def RemoteLaunch(self, argv, envp, stdin_path, stdout_path, stderr_path, working_directory, launch_flags, stop_at_entry, error):
        """
        RemoteLaunch(SBProcess self, char const ** argv, char const ** envp, char const * stdin_path, char const * stdout_path, char const * stderr_path, char const * working_directory, uint32_t launch_flags, bool stop_at_entry, SBError error) -> bool
        See SBTarget.Launch for argument description and usage.
        """
    def GetNumThreads(self):
        """GetNumThreads(SBProcess self) -> uint32_t"""
    def GetThreadAtIndex(self, index):
        """

        Returns the INDEX'th thread from the list of current threads.  The index
        of a thread is only valid for the current stop.  For a persistent thread
        identifier use either the thread ID or the IndexID.  See help on SBThread
        for more details.
        """
    def GetThreadByID(self, sb_thread_id):
        """

        Returns the thread with the given thread ID.
        """
    def GetThreadByIndexID(self, index_id):
        """

        Returns the thread with the given thread IndexID.
        """
    def GetSelectedThread(self):
        """

        Returns the currently selected thread.
        """
    def CreateOSPluginThread(self, tid, context):
        """

        Lazily create a thread on demand through the current OperatingSystem plug-in, if the current OperatingSystem plug-in supports it.
        """
    def SetSelectedThread(self, thread):
        """SetSelectedThread(SBProcess self, SBThread thread) -> bool"""
    def SetSelectedThreadByID(self, tid):
        """SetSelectedThreadByID(SBProcess self, lldb::tid_t tid) -> bool"""
    def SetSelectedThreadByIndexID(self, index_id):
        """SetSelectedThreadByIndexID(SBProcess self, uint32_t index_id) -> bool"""
    def GetNumQueues(self):
        """GetNumQueues(SBProcess self) -> uint32_t"""
    def GetQueueAtIndex(self, index):
        """GetQueueAtIndex(SBProcess self, size_t index) -> SBQueue"""
    def GetState(self):
        """GetState(SBProcess self) -> lldb::StateType"""
    def GetExitStatus(self):
        """GetExitStatus(SBProcess self) -> int"""
    def GetExitDescription(self):
        """GetExitDescription(SBProcess self) -> char const *"""
    def GetProcessID(self):
        """

        Returns the process ID of the process.
        """
    def GetUniqueID(self):
        """

        Returns an integer ID that is guaranteed to be unique across all process instances. This is not the process ID, just a unique integer for comparison and caching purposes.
        """
    def GetAddressByteSize(self):
        """GetAddressByteSize(SBProcess self) -> uint32_t"""
    def Destroy(self):
        """
        Destroy(SBProcess self) -> SBError

            Kills the process and shuts down all threads that were spawned to
            track and monitor process.
        """
    def Continue(self):
        """Continue(SBProcess self) -> SBError"""
    def Stop(self):
        """Stop(SBProcess self) -> SBError"""
    def Kill(self):
        """
        Kill(SBProcess self) -> SBError
        Same as Destroy(self).
        """
    def Detach(self, *args):
        """
        Detach(SBProcess self) -> SBError
        Detach(SBProcess self, bool keep_stopped) -> SBError
        """
    def Signal(self, signal):
        """
        Signal(SBProcess self, int signal) -> SBError
        Sends the process a unix signal.
        """
    def GetUnixSignals(self):
        """GetUnixSignals(SBProcess self) -> SBUnixSignals"""
    def SendAsyncInterrupt(self):
        """SendAsyncInterrupt(SBProcess self)"""
    def GetStopID(self, include_expression_stops: bool = False):
        """
        GetStopID(SBProcess self, bool include_expression_stops=False) -> uint32_t

            Returns a stop id that will increase every time the process executes.  If
            include_expression_stops is true, then stops caused by expression evaluation
            will cause the returned value to increase, otherwise the counter returned will
            only increase when execution is continued explicitly by the user.  Note, the value
            will always increase, but may increase by more than one per stop.
        """
    def GetStopEventForStopID(self, stop_id):
        """GetStopEventForStopID(SBProcess self, uint32_t stop_id) -> SBEvent"""
    def ForceScriptedState(self, new_state):
        """ForceScriptedState(SBProcess self, lldb::StateType new_state)"""
    def ReadMemory(self, addr, buf, error):
        """

        Reads memory from the current process's address space and removes any
        traps that may have been inserted into the memory. It returns the byte
        buffer in a Python string. Example: ::

            # Read 4 bytes from address 'addr' and assume error.Success() is True.
            content = process.ReadMemory(addr, 4, error)
            new_bytes = bytearray(content)
        """
    def WriteMemory(self, addr, buf, error):
        """

        Writes memory to the current process's address space and maintains any
        traps that might be present due to software breakpoints. Example: ::

            # Create a Python string from the byte array.
            new_value = str(bytes)
            result = process.WriteMemory(addr, new_value, error)
            if not error.Success() or result != len(bytes):
                print('SBProcess.WriteMemory() failed!')
        """
    def ReadCStringFromMemory(self, addr, char_buf, error):
        """

        Reads a NULL terminated C string from the current process's address space.
        It returns a python string of the exact length, or truncates the string if
        the maximum character limit is reached. Example: ::

            # Read a C string of at most 256 bytes from address '0x1000'
            error = lldb.SBError()
            cstring = process.ReadCStringFromMemory(0x1000, 256, error)
            if error.Success():
                print('cstring: ', cstring)
            else
                print('error: ', error)
        """
    def ReadUnsignedFromMemory(self, addr, byte_size, error):
        """

        Reads an unsigned integer from memory given a byte size and an address.
        Returns the unsigned integer that was read. Example: ::

            # Read a 4 byte unsigned integer from address 0x1000
            error = lldb.SBError()
            uint = ReadUnsignedFromMemory(0x1000, 4, error)
            if error.Success():
                print('integer: %u' % uint)
            else
                print('error: ', error)
        """
    def ReadPointerFromMemory(self, addr, error):
        """

        Reads a pointer from memory from an address and returns the value. Example: ::

            # Read a pointer from address 0x1000
            error = lldb.SBError()
            ptr = ReadPointerFromMemory(0x1000, error)
            if error.Success():
                print('pointer: 0x%x' % ptr)
            else
                print('error: ', error)
        """
    @staticmethod
    def GetStateFromEvent(event):
        """GetStateFromEvent(SBEvent event) -> lldb::StateType"""
    @staticmethod
    def GetRestartedFromEvent(event):
        """GetRestartedFromEvent(SBEvent event) -> bool"""
    @staticmethod
    def GetNumRestartedReasonsFromEvent(event):
        """GetNumRestartedReasonsFromEvent(SBEvent event) -> size_t"""
    @staticmethod
    def GetRestartedReasonAtIndexFromEvent(event, idx):
        """GetRestartedReasonAtIndexFromEvent(SBEvent event, size_t idx) -> char const *"""
    @staticmethod
    def GetProcessFromEvent(event):
        """GetProcessFromEvent(SBEvent event) -> SBProcess"""
    @staticmethod
    def GetInterruptedFromEvent(event):
        """GetInterruptedFromEvent(SBEvent event) -> bool"""
    @staticmethod
    def GetStructuredDataFromEvent(event):
        """GetStructuredDataFromEvent(SBEvent event) -> SBStructuredData"""
    @staticmethod
    def EventIsProcessEvent(event):
        """EventIsProcessEvent(SBEvent event) -> bool"""
    @staticmethod
    def EventIsStructuredDataEvent(event):
        """EventIsStructuredDataEvent(SBEvent event) -> bool"""
    def GetBroadcaster(self):
        """GetBroadcaster(SBProcess self) -> SBBroadcaster"""
    @staticmethod
    def GetBroadcasterClass():
        """Get default process broadcaster class name (lldb.process)."""
    def GetDescription(self, description):
        """GetDescription(SBProcess self, SBStream description) -> bool"""
    def GetExtendedCrashInformation(self):
        """

        Returns the process' extended crash information.
        """
    def GetNumSupportedHardwareWatchpoints(self, error):
        """GetNumSupportedHardwareWatchpoints(SBProcess self, SBError error) -> uint32_t"""
    def LoadImage(self, *args):
        """
        LoadImage(SBProcess self, SBFileSpec remote_image_spec, SBError error) -> uint32_t
        LoadImage(SBProcess self, SBFileSpec local_image_spec, SBFileSpec remote_image_spec, SBError error) -> uint32_t
        """
    def LoadImageUsingPaths(self, image_spec, paths, loaded_path, error):
        """

        Load the library whose filename is given by image_spec looking in all the
        paths supplied in the paths argument.  If successful, return a token that
        can be passed to UnloadImage and fill loaded_path with the path that was
        successfully loaded.  On failure, return
        lldb.LLDB_INVALID_IMAGE_TOKEN.
        """
    def UnloadImage(self, image_token):
        """UnloadImage(SBProcess self, uint32_t image_token) -> SBError"""
    def SendEventData(self, data):
        """SendEventData(SBProcess self, char const * data) -> SBError"""
    def GetNumExtendedBacktraceTypes(self):
        """

        Return the number of different thread-origin extended backtraces
        this process can support as a uint32_t.
        When the process is stopped and you have an SBThread, lldb may be
        able to show a backtrace of when that thread was originally created,
        or the work item was enqueued to it (in the case of a libdispatch
        queue).
        """
    def GetExtendedBacktraceTypeAtIndex(self, idx):
        """

        Takes an index argument, returns the name of one of the thread-origin
        extended backtrace methods as a str.
        """
    def GetHistoryThreads(self, addr):
        """GetHistoryThreads(SBProcess self, lldb::addr_t addr) -> SBThreadCollection"""
    def IsInstrumentationRuntimePresent(self, type):
        """IsInstrumentationRuntimePresent(SBProcess self, lldb::InstrumentationRuntimeType type) -> bool"""
    def SaveCore(self, *args):
        """
        SaveCore(SBProcess self, char const * file_name, char const * flavor, lldb::SaveCoreStyle core_style) -> SBError
        SaveCore(SBProcess self, char const * file_name) -> SBError
        """
    def GetMemoryRegionInfo(self, load_addr, region_info):
        """GetMemoryRegionInfo(SBProcess self, lldb::addr_t load_addr, SBMemoryRegionInfo region_info) -> SBError"""
    def GetMemoryRegions(self):
        """GetMemoryRegions(SBProcess self) -> SBMemoryRegionInfoList"""
    def GetProcessInfo(self):
        """

        Get information about the process.
        Valid process info will only be returned when the process is alive,
        use IsValid() to check if the info returned is valid. ::

            process_info = process.GetProcessInfo()
            if process_info.IsValid():
                process_info.GetProcessID()
        """
    def AllocateMemory(self, size, permissions, error):
        """

        Allocates a block of memory within the process, with size and
        access permissions specified in the arguments. The permissions
        argument is an or-combination of zero or more of
        lldb.ePermissionsWritable, lldb.ePermissionsReadable, and
        lldb.ePermissionsExecutable. Returns the address
        of the allocated buffer in the process, or
        lldb.LLDB_INVALID_ADDRESS if the allocation failed.
        """
    def DeallocateMemory(self, ptr):
        """

        Deallocates the block of memory (previously allocated using
        AllocateMemory) given in the argument.
        """
    def GetScriptedImplementation(self):
        """

        Returns the implementation object of the process plugin if available. None
        otherwise.
        """
    def WriteMemoryAsCString(self, addr, str, error):
        """
          WriteMemoryAsCString(self, addr, str, error):
            This functions the same as `WriteMemory` except a null-terminator is appended
            to the end of the buffer if it is not there already.
        """
    def __get_is_alive__(self):
        '''Returns "True" if the process is currently alive, "False" otherwise'''
    def __get_is_running__(self):
        '''Returns "True" if the process is currently running, "False" otherwise'''
    def __get_is_stopped__(self):
        '''Returns "True" if the process is currently stopped, "False" otherwise'''
    class threads_access:
        """A helper object that will lazily hand out thread for a process when supplied an index."""
        sbprocess: Incomplete
        def __init__(self, sbprocess) -> None: ...
        def __len__(self) -> int: ...
        def __getitem__(self, key): ...
    def get_threads_access_object(self):
        """An accessor function that returns a modules_access() object which allows lazy thread access from a lldb.SBProcess object."""
    def get_process_thread_list(self):
        """An accessor function that returns a list() that contains all threads in a lldb.SBProcess object."""
    def __iter__(self):
        """Iterate over all threads in a lldb.SBProcess object."""
    def __len__(self) -> int:
        """Return the number of threads in a lldb.SBProcess object."""
    def __int__(self) -> int: ...
    threads: Incomplete
    thread: Incomplete
    is_alive: Incomplete
    is_running: Incomplete
    is_stopped: Incomplete
    id: Incomplete
    target: Incomplete
    num_threads: Incomplete
    selected_thread: Incomplete
    state: Incomplete
    exit_state: Incomplete
    exit_description: Incomplete
    broadcaster: Incomplete

class SBProcessInfo:
    """
    Describes an existing process and any discoverable information that pertains to
    that process.
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBProcessInfo self) -> SBProcessInfo
        __init__(SBProcessInfo self, SBProcessInfo rhs) -> SBProcessInfo
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBProcessInfo self) -> bool"""
    def GetName(self):
        """GetName(SBProcessInfo self) -> char const *"""
    def GetExecutableFile(self):
        """GetExecutableFile(SBProcessInfo self) -> SBFileSpec"""
    def GetProcessID(self):
        """GetProcessID(SBProcessInfo self) -> lldb::pid_t"""
    def GetUserID(self):
        """GetUserID(SBProcessInfo self) -> uint32_t"""
    def GetGroupID(self):
        """GetGroupID(SBProcessInfo self) -> uint32_t"""
    def UserIDIsValid(self):
        """UserIDIsValid(SBProcessInfo self) -> bool"""
    def GroupIDIsValid(self):
        """GroupIDIsValid(SBProcessInfo self) -> bool"""
    def GetEffectiveUserID(self):
        """GetEffectiveUserID(SBProcessInfo self) -> uint32_t"""
    def GetEffectiveGroupID(self):
        """GetEffectiveGroupID(SBProcessInfo self) -> uint32_t"""
    def EffectiveUserIDIsValid(self):
        """EffectiveUserIDIsValid(SBProcessInfo self) -> bool"""
    def EffectiveGroupIDIsValid(self):
        """EffectiveGroupIDIsValid(SBProcessInfo self) -> bool"""
    def GetParentProcessID(self):
        """GetParentProcessID(SBProcessInfo self) -> lldb::pid_t"""
    def GetTriple(self):
        """
        GetTriple(SBProcessInfo self) -> char const *
        Return the target triple (arch-vendor-os) for the described process.
        """

class SBProcessInfoList:
    """Proxy of C++ lldb::SBProcessInfoList class."""
    thisown: Incomplete
    __swig_destroy__: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBProcessInfoList self) -> SBProcessInfoList
        __init__(SBProcessInfoList self, SBProcessInfoList rhs) -> SBProcessInfoList
        """
    def GetSize(self):
        """GetSize(SBProcessInfoList self) -> uint32_t"""
    def GetProcessInfoAtIndex(self, idx, info):
        """GetProcessInfoAtIndex(SBProcessInfoList self, uint32_t idx, SBProcessInfo info) -> bool"""
    def Clear(self):
        """Clear(SBProcessInfoList self)"""
    def __len__(self) -> int:
        """Return the number of process info in a lldb.SBProcessInfoListExtensions object."""
    def __iter__(self):
        """Iterate over all the process info in a lldb.SBProcessInfoListExtensions object."""

class SBQueue:
    """Represents a libdispatch queue in the process."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBQueue self) -> SBQueue
        __init__(SBQueue self, SBQueue rhs) -> SBQueue
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBQueue self) -> bool"""
    def Clear(self):
        """Clear(SBQueue self)"""
    def GetProcess(self):
        """GetProcess(SBQueue self) -> SBProcess"""
    def GetQueueID(self):
        """

        Returns an lldb::queue_id_t type unique identifier number for this
        queue that will not be used by any other queue during this process'
        execution.  These ID numbers often start at 1 with the first
        system-created queues and increment from there.
        """
    def GetName(self):
        """GetName(SBQueue self) -> char const *"""
    def GetIndexID(self):
        """GetIndexID(SBQueue self) -> uint32_t"""
    def GetNumThreads(self):
        """GetNumThreads(SBQueue self) -> uint32_t"""
    def GetThreadAtIndex(self, arg2):
        """GetThreadAtIndex(SBQueue self, uint32_t arg2) -> SBThread"""
    def GetNumPendingItems(self):
        """GetNumPendingItems(SBQueue self) -> uint32_t"""
    def GetPendingItemAtIndex(self, arg2):
        """GetPendingItemAtIndex(SBQueue self, uint32_t arg2) -> SBQueueItem"""
    def GetNumRunningItems(self):
        """GetNumRunningItems(SBQueue self) -> uint32_t"""
    def GetKind(self):
        """

        Returns an lldb::QueueKind enumerated value (e.g. eQueueKindUnknown,
        eQueueKindSerial, eQueueKindConcurrent) describing the type of this
        queue.
        """

class SBQueueItem:
    """This class represents an item in an :py:class:`SBQueue`."""
    thisown: Incomplete
    def __init__(self) -> None:
        """__init__(SBQueueItem self) -> SBQueueItem"""
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBQueueItem self) -> bool"""
    def Clear(self):
        """Clear(SBQueueItem self)"""
    def GetKind(self):
        """GetKind(SBQueueItem self) -> lldb::QueueItemKind"""
    def SetKind(self, kind):
        """SetKind(SBQueueItem self, lldb::QueueItemKind kind)"""
    def GetAddress(self):
        """GetAddress(SBQueueItem self) -> SBAddress"""
    def SetAddress(self, addr):
        """SetAddress(SBQueueItem self, SBAddress addr)"""
    def GetExtendedBacktraceThread(self, type):
        """GetExtendedBacktraceThread(SBQueueItem self, char const * type) -> SBThread"""
    def __hex__(self): ...

class SBReproducer:
    """Controls LLDB's reproducer functionality."""
    thisown: Incomplete
    @staticmethod
    def Capture(path):
        """Capture(char const * path) -> char const *"""
    @staticmethod
    def PassiveReplay(path):
        """PassiveReplay(char const * path) -> char const *"""
    @staticmethod
    def SetAutoGenerate(b):
        """SetAutoGenerate(bool b) -> bool"""
    @staticmethod
    def SetWorkingDirectory(path):
        """SetWorkingDirectory(char const * path)"""
    def __init__(self) -> None:
        """__init__(SBReproducer self) -> SBReproducer"""
    __swig_destroy__: Incomplete

class SBScriptObject:
    """Proxy of C++ lldb::SBScriptObject class."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBScriptObject self, lldb::ScriptObjectPtr const ptr, lldb::ScriptLanguage lang) -> SBScriptObject
        __init__(SBScriptObject self, SBScriptObject rhs) -> SBScriptObject
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def __ne__(self, rhs):
        """__ne__(SBScriptObject self, SBScriptObject rhs) -> bool"""
    def IsValid(self):
        """IsValid(SBScriptObject self) -> bool"""
    def GetPointer(self):
        """GetPointer(SBScriptObject self) -> lldb::ScriptObjectPtr"""
    def GetLanguage(self):
        """GetLanguage(SBScriptObject self) -> lldb::ScriptLanguage"""
    def __eq__(self, other): ...
    ptr: Incomplete
    lang: Incomplete

class SBSection:
    """
    Represents an executable image section.

    SBSection supports iteration through its subsection, represented as SBSection
    as well.  For example, ::

        for sec in exe_module:
            if sec.GetName() == '__TEXT':
                print sec
                break
        print INDENT + 'Number of subsections: %d' % sec.GetNumSubSections()
        for subsec in sec:
            print INDENT + repr(subsec)

    produces: ::

      [0x0000000100000000-0x0000000100002000) a.out.__TEXT
          Number of subsections: 6
          [0x0000000100001780-0x0000000100001d5c) a.out.__TEXT.__text
          [0x0000000100001d5c-0x0000000100001da4) a.out.__TEXT.__stubs
          [0x0000000100001da4-0x0000000100001e2c) a.out.__TEXT.__stub_helper
          [0x0000000100001e2c-0x0000000100001f10) a.out.__TEXT.__cstring
          [0x0000000100001f10-0x0000000100001f68) a.out.__TEXT.__unwind_info
          [0x0000000100001f68-0x0000000100001ff8) a.out.__TEXT.__eh_frame

    See also :py:class:`SBModule` .
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBSection self) -> SBSection
        __init__(SBSection self, SBSection rhs) -> SBSection
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBSection self) -> bool"""
    def GetName(self):
        """GetName(SBSection self) -> char const *"""
    def GetParent(self):
        """GetParent(SBSection self) -> SBSection"""
    def FindSubSection(self, sect_name):
        """FindSubSection(SBSection self, char const * sect_name) -> SBSection"""
    def GetNumSubSections(self):
        """GetNumSubSections(SBSection self) -> size_t"""
    def GetSubSectionAtIndex(self, idx):
        """GetSubSectionAtIndex(SBSection self, size_t idx) -> SBSection"""
    def GetFileAddress(self):
        """GetFileAddress(SBSection self) -> lldb::addr_t"""
    def GetLoadAddress(self, target):
        """GetLoadAddress(SBSection self, SBTarget target) -> lldb::addr_t"""
    def GetByteSize(self):
        """GetByteSize(SBSection self) -> lldb::addr_t"""
    def GetFileOffset(self):
        """GetFileOffset(SBSection self) -> uint64_t"""
    def GetFileByteSize(self):
        """GetFileByteSize(SBSection self) -> uint64_t"""
    def GetSectionData(self, *args):
        """
        GetSectionData(SBSection self) -> SBData
        GetSectionData(SBSection self, uint64_t offset, uint64_t size) -> SBData
        """
    def GetSectionType(self):
        """GetSectionType(SBSection self) -> lldb::SectionType"""
    def GetPermissions(self):
        """GetPermissions(SBSection self) -> uint32_t"""
    def GetTargetByteSize(self):
        """
        GetTargetByteSize(SBSection self) -> uint32_t

            Return the size of a target's byte represented by this section
            in numbers of host bytes. Note that certain architectures have
            varying minimum addressable unit (i.e. byte) size for their
            CODE or DATA buses.

            @return
                The number of host (8-bit) bytes needed to hold a target byte
        """
    def GetAlignment(self):
        """GetAlignment(SBSection self) -> uint32_t"""
    def __eq__(self, rhs):
        """__eq__(SBSection self, SBSection rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBSection self, SBSection rhs) -> bool"""
    def GetDescription(self, description):
        """GetDescription(SBSection self, SBStream description) -> bool"""
    def __eq__(self, other): ...
    def __iter__(self):
        """Iterate over all subsections in a lldb.SBSection object."""
    def __len__(self) -> int:
        """Return the number of subsections in a lldb.SBSection object."""
    def get_addr(self): ...
    name: Incomplete
    addr: Incomplete
    file_addr: Incomplete
    size: Incomplete
    file_offset: Incomplete
    file_size: Incomplete
    data: Incomplete
    type: Incomplete
    target_byte_size: Incomplete
    alignment: Incomplete
    def __eq__(self, rhs): ...
    def __ne__(self, rhs): ...

class SBSourceManager:
    """
    Represents a central authority for displaying source code.

    For example (from test/source-manager/TestSourceManager.py), ::

            # Create the filespec for 'main.c'.
            filespec = lldb.SBFileSpec('main.c', False)
            source_mgr = self.dbg.GetSourceManager()
            # Use a string stream as the destination.
            stream = lldb.SBStream()
            source_mgr.DisplaySourceLinesWithLineNumbers(filespec,
                                                         self.line,
                                                         2, # context before
                                                         2, # context after
                                                         '=>', # prefix for current line
                                                         stream)

            #    2
            #    3    int main(int argc, char const *argv[]) {
            # => 4        printf('Hello world.\\n'); // Set break point at this line.
            #    5        return 0;
            #    6    }
            self.expect(stream.GetData(), 'Source code displayed correctly',
                        exe=False,
                patterns = ['=> %d.*Hello world' % self.line])
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBSourceManager self, SBDebugger debugger) -> SBSourceManager
        __init__(SBSourceManager self, SBTarget target) -> SBSourceManager
        __init__(SBSourceManager self, SBSourceManager rhs) -> SBSourceManager
        """
    __swig_destroy__: Incomplete
    def DisplaySourceLinesWithLineNumbers(self, file, line, context_before, context_after, current_line_cstr, s):
        """DisplaySourceLinesWithLineNumbers(SBSourceManager self, SBFileSpec file, uint32_t line, uint32_t context_before, uint32_t context_after, char const * current_line_cstr, SBStream s) -> size_t"""
    def DisplaySourceLinesWithLineNumbersAndColumn(self, file, line, column, context_before, context_after, current_line_cstr, s):
        """DisplaySourceLinesWithLineNumbersAndColumn(SBSourceManager self, SBFileSpec file, uint32_t line, uint32_t column, uint32_t context_before, uint32_t context_after, char const * current_line_cstr, SBStream s) -> size_t"""

class SBStream:
    """
    Represents a destination for streaming data output to. By default, a string
    stream is created.

    For example (from test/source-manager/TestSourceManager.py), ::

            # Create the filespec for 'main.c'.
            filespec = lldb.SBFileSpec('main.c', False)
            source_mgr = self.dbg.GetSourceManager()
            # Use a string stream as the destination.
            stream = lldb.SBStream()
            source_mgr.DisplaySourceLinesWithLineNumbers(filespec,
                                                         self.line,
                                                         2, # context before
                                                         2, # context after
                                                         '=>', # prefix for current line
                                                         stream)

            #    2
            #    3    int main(int argc, char const *argv[]) {
            # => 4        printf('Hello world.\\n'); // Set break point at this line.
            #    5        return 0;
            #    6    }
            self.expect(stream.GetData(), 'Source code displayed correctly',
                        exe=False,
                patterns = ['=> %d.*Hello world' % self.line])
    """
    thisown: Incomplete
    def __init__(self) -> None:
        """__init__(SBStream self) -> SBStream"""
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBStream self) -> bool"""
    def GetData(self):
        """
        GetData(SBStream self) -> char const *

            If this stream is not redirected to a file, it will maintain a local
            cache for the stream data which can be accessed using this accessor.
        """
    def GetSize(self):
        """
        GetSize(SBStream self) -> size_t

            If this stream is not redirected to a file, it will maintain a local
            cache for the stream output whose length can be accessed using this
            accessor.
        """
    def Print(self, str):
        """Print(SBStream self, char const * str)"""
    def RedirectToFile(self, *args):
        """
        RedirectToFile(SBStream self, char const * path, bool append)
        RedirectToFile(SBStream self, SBFile file)
        RedirectToFile(SBStream self, lldb::FileSP file)
        """
    def RedirectToFileDescriptor(self, fd, transfer_fh_ownership):
        """RedirectToFileDescriptor(SBStream self, int fd, bool transfer_fh_ownership)"""
    def Clear(self):
        """
        Clear(SBStream self)

            If the stream is redirected to a file, forget about the file and if
            ownership of the file was transferred to this object, close the file.
            If the stream is backed by a local cache, clear this cache.
        """
    def __len__(self) -> int: ...
    def RedirectToFileHandle(self, file, transfer_fh_ownership):
        """DEPRECATED, use RedirectToFile"""
    def write(self, str):
        """write(SBStream self, char const * str)"""
    def flush(self):
        """flush(SBStream self)"""

class SBStringList:
    """Represents a list of strings."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBStringList self) -> SBStringList
        __init__(SBStringList self, SBStringList rhs) -> SBStringList
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBStringList self) -> bool"""
    def AppendString(self, str):
        """AppendString(SBStringList self, char const * str)"""
    def AppendList(self, *args):
        """
        AppendList(SBStringList self, char const ** strv, int strc)
        AppendList(SBStringList self, SBStringList strings)
        """
    def GetSize(self):
        """GetSize(SBStringList self) -> uint32_t"""
    def GetStringAtIndex(self, *args):
        """
        GetStringAtIndex(SBStringList self, size_t idx) -> char const
        GetStringAtIndex(SBStringList self, size_t idx) -> char const *
        """
    def Clear(self):
        """Clear(SBStringList self)"""
    def __iter__(self):
        """Iterate over all strings in a lldb.SBStringList object."""
    def __len__(self) -> int:
        """Return the number of strings in a lldb.SBStringList object."""

class SBStructuredData:
    """
    A class representing a StructuredData event.

    This class wraps the event type generated by StructuredData features.
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBStructuredData self) -> SBStructuredData
        __init__(SBStructuredData self, SBStructuredData rhs) -> SBStructuredData
        __init__(SBStructuredData self, SBScriptObject obj, SBDebugger debugger) -> SBStructuredData
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBStructuredData self) -> bool"""
    def SetFromJSON(self, *args):
        """
        SetFromJSON(SBStructuredData self, SBStream stream) -> SBError
        SetFromJSON(SBStructuredData self, char const * json) -> SBError
        """
    def Clear(self):
        """Clear(SBStructuredData self)"""
    def GetAsJSON(self, stream):
        """GetAsJSON(SBStructuredData self, SBStream stream) -> SBError"""
    def GetDescription(self, stream):
        """GetDescription(SBStructuredData self, SBStream stream) -> SBError"""
    def GetType(self):
        """GetType(SBStructuredData self) -> lldb::StructuredDataType"""
    def GetSize(self):
        """GetSize(SBStructuredData self) -> size_t"""
    def GetKeys(self, keys):
        """GetKeys(SBStructuredData self, SBStringList keys) -> bool"""
    def GetValueForKey(self, key):
        """GetValueForKey(SBStructuredData self, char const * key) -> SBStructuredData"""
    def GetItemAtIndex(self, idx):
        """GetItemAtIndex(SBStructuredData self, size_t idx) -> SBStructuredData"""
    def GetUnsignedIntegerValue(self, fail_value: int = 0):
        """GetUnsignedIntegerValue(SBStructuredData self, uint64_t fail_value=0) -> uint64_t"""
    def GetSignedIntegerValue(self, fail_value: int = 0):
        """GetSignedIntegerValue(SBStructuredData self, int64_t fail_value=0) -> int64_t"""
    def GetIntegerValue(self, fail_value: int = 0):
        """GetIntegerValue(SBStructuredData self, uint64_t fail_value=0) -> uint64_t"""
    def GetFloatValue(self, fail_value: float = 0.0):
        """GetFloatValue(SBStructuredData self, double fail_value=0.0) -> double"""
    def GetBooleanValue(self, fail_value: bool = False):
        """GetBooleanValue(SBStructuredData self, bool fail_value=False) -> bool"""
    def GetStringValue(self, dst):
        """GetStringValue(SBStructuredData self, char * dst) -> size_t"""
    def GetGenericValue(self):
        """GetGenericValue(SBStructuredData self) -> SBScriptObject"""
    def __int__(self) -> int: ...
    def __len__(self) -> int:
        """Return the number of element in a lldb.SBStructuredData object."""
    def __iter__(self):
        """Iterate over all the elements in a lldb.SBStructuredData object."""

class SBSymbol:
    """
    Represents the symbol possibly associated with a stack frame.
    :py:class:`SBModule` contains SBSymbol(s). SBSymbol can also be retrieved from :py:class:`SBFrame` .
    """
    thisown: Incomplete
    __swig_destroy__: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBSymbol self) -> SBSymbol
        __init__(SBSymbol self, SBSymbol rhs) -> SBSymbol
        """
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBSymbol self) -> bool"""
    def GetName(self):
        """GetName(SBSymbol self) -> char const *"""
    def GetDisplayName(self):
        """GetDisplayName(SBSymbol self) -> char const *"""
    def GetMangledName(self):
        """GetMangledName(SBSymbol self) -> char const *"""
    def GetInstructions(self, *args):
        """
        GetInstructions(SBSymbol self, SBTarget target) -> SBInstructionList
        GetInstructions(SBSymbol self, SBTarget target, char const * flavor_string) -> SBInstructionList
        """
    def GetStartAddress(self):
        """GetStartAddress(SBSymbol self) -> SBAddress"""
    def GetEndAddress(self):
        """GetEndAddress(SBSymbol self) -> SBAddress"""
    def GetValue(self):
        """GetValue(SBSymbol self) -> uint64_t"""
    def GetSize(self):
        """GetSize(SBSymbol self) -> uint64_t"""
    def GetPrologueByteSize(self):
        """GetPrologueByteSize(SBSymbol self) -> uint32_t"""
    def GetType(self):
        """GetType(SBSymbol self) -> lldb::SymbolType"""
    def __eq__(self, rhs):
        """__eq__(SBSymbol self, SBSymbol rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBSymbol self, SBSymbol rhs) -> bool"""
    def GetDescription(self, description):
        """GetDescription(SBSymbol self, SBStream description) -> bool"""
    def IsExternal(self):
        """IsExternal(SBSymbol self) -> bool"""
    def IsSynthetic(self):
        """IsSynthetic(SBSymbol self) -> bool"""
    def __eq__(self, other): ...
    def __hex__(self): ...
    def get_instructions_from_current_target(self): ...
    name: Incomplete
    mangled: Incomplete
    type: Incomplete
    addr: Incomplete
    end_addr: Incomplete
    prologue_size: Incomplete
    instructions: Incomplete
    external: Incomplete
    synthetic: Incomplete
    def __eq__(self, rhs): ...
    def __ne__(self, rhs): ...

class SBSymbolContext:
    """
    A context object that provides access to core debugger entities.

    Many debugger functions require a context when doing lookups. This class
    provides a common structure that can be used as the result of a query that
    can contain a single result.

    For example, ::

            exe = os.path.join(os.getcwd(), 'a.out')

            # Create a target for the debugger.
            target = self.dbg.CreateTarget(exe)

            # Now create a breakpoint on main.c by name 'c'.
            breakpoint = target.BreakpointCreateByName('c', 'a.out')

            # Now launch the process, and do not stop at entry point.
            process = target.LaunchSimple(None, None, os.getcwd())

            # The inferior should stop on 'c'.
            from lldbutil import get_stopped_thread
            thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
            frame0 = thread.GetFrameAtIndex(0)

            # Now get the SBSymbolContext from this frame.  We want everything. :-)
            context = frame0.GetSymbolContext(lldb.eSymbolContextEverything)

            # Get the module.
            module = context.GetModule()
            ...

            # And the compile unit associated with the frame.
            compileUnit = context.GetCompileUnit()
            ...

    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBSymbolContext self) -> SBSymbolContext
        __init__(SBSymbolContext self, SBSymbolContext rhs) -> SBSymbolContext
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBSymbolContext self) -> bool"""
    def GetModule(self):
        """GetModule(SBSymbolContext self) -> SBModule"""
    def GetCompileUnit(self):
        """GetCompileUnit(SBSymbolContext self) -> SBCompileUnit"""
    def GetFunction(self):
        """GetFunction(SBSymbolContext self) -> SBFunction"""
    def GetBlock(self):
        """GetBlock(SBSymbolContext self) -> SBBlock"""
    def GetLineEntry(self):
        """GetLineEntry(SBSymbolContext self) -> SBLineEntry"""
    def GetSymbol(self):
        """GetSymbol(SBSymbolContext self) -> SBSymbol"""
    def SetModule(self, module):
        """SetModule(SBSymbolContext self, SBModule module)"""
    def SetCompileUnit(self, compile_unit):
        """SetCompileUnit(SBSymbolContext self, SBCompileUnit compile_unit)"""
    def SetFunction(self, function):
        """SetFunction(SBSymbolContext self, SBFunction function)"""
    def SetBlock(self, block):
        """SetBlock(SBSymbolContext self, SBBlock block)"""
    def SetLineEntry(self, line_entry):
        """SetLineEntry(SBSymbolContext self, SBLineEntry line_entry)"""
    def SetSymbol(self, symbol):
        """SetSymbol(SBSymbolContext self, SBSymbol symbol)"""
    def GetParentOfInlinedScope(self, curr_frame_pc, parent_frame_addr):
        """GetParentOfInlinedScope(SBSymbolContext self, SBAddress curr_frame_pc, SBAddress parent_frame_addr) -> SBSymbolContext"""
    def GetDescription(self, description):
        """GetDescription(SBSymbolContext self, SBStream description) -> bool"""
    module: Incomplete
    compile_unit: Incomplete
    function: Incomplete
    block: Incomplete
    symbol: Incomplete
    line_entry: Incomplete

class SBSymbolContextList:
    """
    Represents a list of symbol context object. See also SBSymbolContext.

    For example (from test/python_api/target/TestTargetAPI.py), ::

        def find_functions(self, exe_name):
            '''Exercise SBTarget.FindFunctions() API.'''
            exe = os.path.join(os.getcwd(), exe_name)

            # Create a target by the debugger.
            target = self.dbg.CreateTarget(exe)
            self.assertTrue(target, VALID_TARGET)

            list = lldb.SBSymbolContextList()
            num = target.FindFunctions('c', lldb.eFunctionNameTypeAuto, False, list)
            self.assertTrue(num == 1 and list.GetSize() == 1)

            for sc in list:
                self.assertTrue(sc.GetModule().GetFileSpec().GetFilename() == exe_name)
                self.assertTrue(sc.GetSymbol().GetName() == 'c')
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBSymbolContextList self) -> SBSymbolContextList
        __init__(SBSymbolContextList self, SBSymbolContextList rhs) -> SBSymbolContextList
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBSymbolContextList self) -> bool"""
    def GetSize(self):
        """GetSize(SBSymbolContextList self) -> uint32_t"""
    def GetContextAtIndex(self, idx):
        """GetContextAtIndex(SBSymbolContextList self, uint32_t idx) -> SBSymbolContext"""
    def GetDescription(self, description):
        """GetDescription(SBSymbolContextList self, SBStream description) -> bool"""
    def Append(self, *args):
        """
        Append(SBSymbolContextList self, SBSymbolContext sc)
        Append(SBSymbolContextList self, SBSymbolContextList sc_list)
        """
    def Clear(self):
        """Clear(SBSymbolContextList self)"""
    def __iter__(self):
        """Iterate over all symbol contexts in a lldb.SBSymbolContextList
        object."""
    def __len__(self) -> int: ...
    def __getitem__(self, key): ...
    def get_module_array(self): ...
    def get_compile_unit_array(self): ...
    def get_function_array(self): ...
    def get_block_array(self): ...
    def get_symbol_array(self): ...
    def get_line_entry_array(self): ...
    modules: Incomplete
    compile_units: Incomplete
    functions: Incomplete
    blocks: Incomplete
    line_entries: Incomplete
    symbols: Incomplete

class SBTarget:
    """
    Represents the target program running under the debugger.

    SBTarget supports module, breakpoint, and watchpoint iterations. For example, ::

        for m in target.module_iter():
            print m

    produces: ::

        (x86_64) /Volumes/data/lldb/svn/trunk/test/python_api/lldbutil/iter/a.out
        (x86_64) /usr/lib/dyld
        (x86_64) /usr/lib/libstdc++.6.dylib
        (x86_64) /usr/lib/libSystem.B.dylib
        (x86_64) /usr/lib/system/libmathCommon.A.dylib
        (x86_64) /usr/lib/libSystem.B.dylib(__commpage)

    and, ::

        for b in target.breakpoint_iter():
            print b

    produces: ::

        SBBreakpoint: id = 1, file ='main.cpp', line = 66, locations = 1
        SBBreakpoint: id = 2, file ='main.cpp', line = 85, locations = 1

    and, ::

        for wp_loc in target.watchpoint_iter():
            print wp_loc

    produces: ::

        Watchpoint 1: addr = 0x1034ca048 size = 4 state = enabled type = rw
            declare @ '/Volumes/data/lldb/svn/trunk/test/python_api/watchpoint/main.c:12'
            hit_count = 2     ignore_count = 0
    """
    thisown: Incomplete
    eBroadcastBitBreakpointChanged: Incomplete
    eBroadcastBitModulesLoaded: Incomplete
    eBroadcastBitModulesUnloaded: Incomplete
    eBroadcastBitWatchpointChanged: Incomplete
    eBroadcastBitSymbolsLoaded: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBTarget self) -> SBTarget
        __init__(SBTarget self, SBTarget rhs) -> SBTarget
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBTarget self) -> bool"""
    @staticmethod
    def EventIsTargetEvent(event):
        """EventIsTargetEvent(SBEvent event) -> bool"""
    @staticmethod
    def GetTargetFromEvent(event):
        """GetTargetFromEvent(SBEvent event) -> SBTarget"""
    @staticmethod
    def GetNumModulesFromEvent(event):
        """GetNumModulesFromEvent(SBEvent event) -> uint32_t"""
    @staticmethod
    def GetModuleAtIndexFromEvent(idx, event):
        """GetModuleAtIndexFromEvent(uint32_t const idx, SBEvent event) -> SBModule"""
    @staticmethod
    def GetBroadcasterClassName():
        """GetBroadcasterClassName() -> char const *"""
    def GetProcess(self):
        """GetProcess(SBTarget self) -> SBProcess"""
    def SetCollectingStats(self, v):
        """SetCollectingStats(SBTarget self, bool v)"""
    def GetCollectingStats(self):
        """GetCollectingStats(SBTarget self) -> bool"""
    def GetStatistics(self):
        """GetStatistics(SBTarget self) -> SBStructuredData"""
    def GetPlatform(self):
        """
        GetPlatform(SBTarget self) -> SBPlatform

            Return the platform object associated with the target.

            After return, the platform object should be checked for
            validity.

            @return
                A platform object.
        """
    def GetEnvironment(self):
        """GetEnvironment(SBTarget self) -> SBEnvironment"""
    def Install(self):
        """
        Install(SBTarget self) -> SBError

            Install any binaries that need to be installed.

            This function does nothing when debugging on the host system.
            When connected to remote platforms, the target's main executable
            and any modules that have their install path set will be
            installed on the remote platform. If the main executable doesn't
            have an install location set, it will be installed in the remote
            platform's working directory.

            @return
                An error describing anything that went wrong during
                installation.
        """
    def LoadCore(self, *args):
        """
        LoadCore(SBTarget self, char const * core_file) -> SBProcess
        LoadCore(SBTarget self, char const * core_file, SBError error) -> SBProcess

            Load a core file

            @param[in] core_file
                File path of the core dump.

            @param[out] error
                An error explaining what went wrong if the operation fails.
                (Optional)

            @return
                 A process object for the newly created core file.

            For example,

                process = target.LoadCore('./a.out.core')

            loads a new core file and returns the process object.
        """
    def LaunchSimple(self, argv, envp, working_directory):
        """
        LaunchSimple(SBTarget self, char const ** argv, char const ** envp, char const * working_directory) -> SBProcess

            Launch a new process with sensible defaults.

            :param argv: The argument array.
            :param envp: The environment array.
            :param working_directory: The working directory to have the child process run in
            :return: The newly created process.
            :rtype: SBProcess

            A pseudo terminal will be used as stdin/stdout/stderr.
            No launch flags are passed and the target's debuger is used as a listener.

            For example, ::

                process = target.LaunchSimple(['X', 'Y', 'Z'], None, os.getcwd())

            launches a new process by passing 'X', 'Y', 'Z' as the args to the
            executable.
        """
    def Launch(self, *args):
        """
        Launch(SBTarget self, SBListener listener, char const ** argv, char const ** envp, char const * stdin_path, char const * stdout_path, char const * stderr_path, char const * working_directory, uint32_t launch_flags, bool stop_at_entry, SBError error) -> SBProcess
        Launch(SBTarget self, SBLaunchInfo launch_info, SBError error) -> SBProcess

            Launch a new process.

            Launch a new process by spawning a new process using the
            target object's executable module's file as the file to launch.
            Arguments are given in argv, and the environment variables
            are in envp. Standard input and output files can be
            optionally re-directed to stdin_path, stdout_path, and
            stderr_path.

            @param[in] listener
                An optional listener that will receive all process events.
                If listener is valid then listener will listen to all
                process events. If not valid, then this target's debugger
                (SBTarget::GetDebugger()) will listen to all process events.

            @param[in] argv
                The argument array.

            @param[in] envp
                The environment array.

            @param[in] launch_flags
                Flags to modify the launch (@see lldb::LaunchFlags)

            @param[in] stdin_path
                The path to use when re-directing the STDIN of the new
                process. If all stdXX_path arguments are NULL, a pseudo
                terminal will be used.

            @param[in] stdout_path
                The path to use when re-directing the STDOUT of the new
                process. If all stdXX_path arguments are NULL, a pseudo
                terminal will be used.

            @param[in] stderr_path
                The path to use when re-directing the STDERR of the new
                process. If all stdXX_path arguments are NULL, a pseudo
                terminal will be used.

            @param[in] working_directory
                The working directory to have the child process run in

            @param[in] launch_flags
                Some launch options specified by logical OR'ing
                lldb::LaunchFlags enumeration values together.

            @param[in] stop_at_entry
                If false do not stop the inferior at the entry point.

            @param[out]
                An error object. Contains the reason if there is some failure.

            @return
                 A process object for the newly created process.

            For example,

                process = target.Launch(self.dbg.GetListener(), None, None,
                                        None, '/tmp/stdout.txt', None,
                                        None, 0, False, error)

            launches a new process by passing nothing for both the args and the envs
            and redirect the standard output of the inferior to the /tmp/stdout.txt
            file. It does not specify a working directory so that the debug server
            will use its idea of what the current working directory is for the
            inferior. Also, we ask the debugger not to stop the inferior at the
            entry point. If no breakpoint is specified for the inferior, it should
            run to completion if no user interaction is required.
        """
    def Attach(self, attach_info, error):
        """Attach(SBTarget self, SBAttachInfo attach_info, SBError error) -> SBProcess"""
    def AttachToProcessWithID(self, listener, pid, error):
        """
        AttachToProcessWithID(SBTarget self, SBListener listener, lldb::pid_t pid, SBError error) -> SBProcess

            Attach to process with pid.

            @param[in] listener
                An optional listener that will receive all process events.
                If listener is valid then listener will listen to all
                process events. If not valid, then this target's debugger
                (SBTarget::GetDebugger()) will listen to all process events.

            @param[in] pid
                The process ID to attach to.

            @param[out]
                An error explaining what went wrong if attach fails.

            @return
                 A process object for the attached process.
        """
    def AttachToProcessWithName(self, listener, name, wait_for, error):
        """
        AttachToProcessWithName(SBTarget self, SBListener listener, char const * name, bool wait_for, SBError error) -> SBProcess

            Attach to process with name.

            @param[in] listener
                An optional listener that will receive all process events.
                If listener is valid then listener will listen to all
                process events. If not valid, then this target's debugger
                (SBTarget::GetDebugger()) will listen to all process events.

            @param[in] name
                Basename of process to attach to.

            @param[in] wait_for
                If true wait for a new instance of 'name' to be launched.

            @param[out]
                An error explaining what went wrong if attach fails.

            @return
                 A process object for the attached process.
        """
    def ConnectRemote(self, listener, url, plugin_name, error):
        """
        ConnectRemote(SBTarget self, SBListener listener, char const * url, char const * plugin_name, SBError error) -> SBProcess

            Connect to a remote debug server with url.

            @param[in] listener
                An optional listener that will receive all process events.
                If listener is valid then listener will listen to all
                process events. If not valid, then this target's debugger
                (SBTarget::GetDebugger()) will listen to all process events.

            @param[in] url
                The url to connect to, e.g., 'connect://localhost:12345'.

            @param[in] plugin_name
                The plugin name to be used; can be NULL.

            @param[out]
                An error explaining what went wrong if the connect fails.

            @return
                 A process object for the connected process.
        """
    def GetExecutable(self):
        """GetExecutable(SBTarget self) -> SBFileSpec"""
    def AppendImageSearchPath(self, _from, to, error):
        """
        AppendImageSearchPath(SBTarget self, char const * _from, char const * to, SBError error)

            Append the path mapping (from -> to) to the target's paths mapping list.
        """
    def AddModule(self, *args):
        """
        AddModule(SBTarget self, SBModule module) -> bool
        AddModule(SBTarget self, char const * path, char const * triple, char const * uuid) -> SBModule
        AddModule(SBTarget self, char const * path, char const * triple, char const * uuid_cstr, char const * symfile) -> SBModule
        AddModule(SBTarget self, SBModuleSpec module_spec) -> SBModule
        """
    def GetNumModules(self):
        """GetNumModules(SBTarget self) -> uint32_t"""
    def GetModuleAtIndex(self, idx):
        """GetModuleAtIndex(SBTarget self, uint32_t idx) -> SBModule"""
    def RemoveModule(self, module):
        """RemoveModule(SBTarget self, SBModule module) -> bool"""
    def GetDebugger(self):
        """GetDebugger(SBTarget self) -> SBDebugger"""
    def FindModule(self, file_spec):
        """FindModule(SBTarget self, SBFileSpec file_spec) -> SBModule"""
    def FindCompileUnits(self, sb_file_spec):
        """
        FindCompileUnits(SBTarget self, SBFileSpec sb_file_spec) -> SBSymbolContextList

            Find compile units related to this target and passed source
            file.

            :param sb_file_spec: A :py:class:`lldb::SBFileSpec` object that contains source file
                specification.
            :return: The symbol contexts for all the matches.
            :rtype: SBSymbolContextList
        """
    def GetByteOrder(self):
        """GetByteOrder(SBTarget self) -> lldb::ByteOrder"""
    def GetAddressByteSize(self):
        """GetAddressByteSize(SBTarget self) -> uint32_t"""
    def GetTriple(self):
        """GetTriple(SBTarget self) -> char const *"""
    def GetABIName(self):
        """GetABIName(SBTarget self) -> char const *"""
    def GetLabel(self):
        """GetLabel(SBTarget self) -> char const *"""
    def SetLabel(self, label):
        """SetLabel(SBTarget self, char const * label) -> SBError"""
    def GetDataByteSize(self):
        """
        GetDataByteSize(SBTarget self) -> uint32_t

            Architecture data byte width accessor

            :return: The size in 8-bit (host) bytes of a minimum addressable unit from the Architecture's data bus.


        """
    def GetCodeByteSize(self):
        """
        GetCodeByteSize(SBTarget self) -> uint32_t

            Architecture code byte width accessor.

            :return: The size in 8-bit (host) bytes of a minimum addressable unit from the Architecture's code bus.


        """
    def GetMaximumNumberOfChildrenToDisplay(self):
        """GetMaximumNumberOfChildrenToDisplay(SBTarget self) -> uint32_t"""
    def SetSectionLoadAddress(self, section, section_base_addr):
        """SetSectionLoadAddress(SBTarget self, SBSection section, lldb::addr_t section_base_addr) -> SBError"""
    def ClearSectionLoadAddress(self, section):
        """ClearSectionLoadAddress(SBTarget self, SBSection section) -> SBError"""
    def SetModuleLoadAddress(self, module, sections_offset):
        """SetModuleLoadAddress(SBTarget self, SBModule module, uint64_t sections_offset) -> SBError"""
    def ClearModuleLoadAddress(self, module):
        """ClearModuleLoadAddress(SBTarget self, SBModule module) -> SBError"""
    def FindFunctions(self, *args):
        """
        FindFunctions(SBTarget self, char const * name, uint32_t name_type_mask=eFunctionNameTypeAny) -> SBSymbolContextList

            Find functions by name.

            :param name: The name of the function we are looking for.

            :param name_type_mask:
                A logical OR of one or more FunctionNameType enum bits that
                indicate what kind of names should be used when doing the
                lookup. Bits include fully qualified names, base names,
                C++ methods, or ObjC selectors.
                See FunctionNameType for more details.

            :return:
                A lldb::SBSymbolContextList that gets filled in with all of
                the symbol contexts for all the matches.
        """
    def FindFirstGlobalVariable(self, name):
        """
        FindFirstGlobalVariable(SBTarget self, char const * name) -> SBValue

            Find the first global (or static) variable by name.

            @param[in] name
                The name of the global or static variable we are looking
                for.

            @return
                An SBValue that gets filled in with the found variable (if any).
        """
    def FindGlobalVariables(self, *args):
        """
        FindGlobalVariables(SBTarget self, char const * name, uint32_t max_matches) -> SBValueList
        FindGlobalVariables(SBTarget self, char const * name, uint32_t max_matches, lldb::MatchType matchtype) -> SBValueList

            Find global and static variables by name.

            @param[in] name
                The name of the global or static variable we are looking
                for.

            @param[in] max_matches
                Allow the number of matches to be limited to max_matches.

            @return
                A list of matched variables in an SBValueList.
        """
    def FindGlobalFunctions(self, name, max_matches, matchtype):
        """FindGlobalFunctions(SBTarget self, char const * name, uint32_t max_matches, lldb::MatchType matchtype) -> SBSymbolContextList"""
    def Clear(self):
        """Clear(SBTarget self)"""
    def ResolveFileAddress(self, file_addr):
        """
        ResolveFileAddress(SBTarget self, lldb::addr_t file_addr) -> SBAddress

            Resolve a current file address into a section offset address.

            @param[in] file_addr

            @return
                An SBAddress which will be valid if...
        """
    def ResolveLoadAddress(self, vm_addr):
        """ResolveLoadAddress(SBTarget self, lldb::addr_t vm_addr) -> SBAddress"""
    def ResolvePastLoadAddress(self, stop_id, vm_addr):
        """ResolvePastLoadAddress(SBTarget self, uint32_t stop_id, lldb::addr_t vm_addr) -> SBAddress"""
    def ResolveSymbolContextForAddress(self, addr, resolve_scope):
        """ResolveSymbolContextForAddress(SBTarget self, SBAddress addr, uint32_t resolve_scope) -> SBSymbolContext"""
    def ReadMemory(self, addr, buf, error):
        """
        ReadMemory(SBTarget self, SBAddress addr, void * buf, SBError error) -> size_t

            Read target memory. If a target process is running then memory
            is read from here. Otherwise the memory is read from the object
            files. For a target whose bytes are sized as a multiple of host
            bytes, the data read back will preserve the target's byte order.

            @param[in] addr
                A target address to read from.

            @param[out] buf
                The buffer to read memory into.

            @param[in] size
                The maximum number of host bytes to read in the buffer passed
                into this call

            @param[out] error
                Error information is written here if the memory read fails.

            @return
                The amount of data read in host bytes.
        """
    def BreakpointCreateByLocation(self, *args):
        """
        BreakpointCreateByLocation(SBTarget self, char const * file, uint32_t line) -> SBBreakpoint
        BreakpointCreateByLocation(SBTarget self, SBFileSpec file_spec, uint32_t line) -> SBBreakpoint
        BreakpointCreateByLocation(SBTarget self, SBFileSpec file_spec, uint32_t line, lldb::addr_t offset) -> SBBreakpoint
        BreakpointCreateByLocation(SBTarget self, SBFileSpec file_spec, uint32_t line, lldb::addr_t offset, SBFileSpecList module_list) -> SBBreakpoint
        BreakpointCreateByLocation(SBTarget self, SBFileSpec file_spec, uint32_t line, uint32_t column, lldb::addr_t offset, SBFileSpecList module_list) -> SBBreakpoint
        BreakpointCreateByLocation(SBTarget self, SBFileSpec file_spec, uint32_t line, uint32_t column, lldb::addr_t offset, SBFileSpecList module_list, bool move_to_nearest_code) -> SBBreakpoint
        """
    def BreakpointCreateByName(self, *args):
        """
        BreakpointCreateByName(SBTarget self, char const * symbol_name, char const * module_name=None) -> SBBreakpoint
        BreakpointCreateByName(SBTarget self, char const * symbol_name, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
        BreakpointCreateByName(SBTarget self, char const * symbol_name, uint32_t name_type_mask, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
        BreakpointCreateByName(SBTarget self, char const * symbol_name, uint32_t name_type_mask, lldb::LanguageType symbol_language, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
        """
    def BreakpointCreateByNames(self, *args):
        """
        BreakpointCreateByNames(SBTarget self, char const ** symbol_name, uint32_t name_type_mask, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
        BreakpointCreateByNames(SBTarget self, char const ** symbol_name, uint32_t name_type_mask, lldb::LanguageType symbol_language, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
        BreakpointCreateByNames(SBTarget self, char const ** symbol_name, uint32_t name_type_mask, lldb::LanguageType symbol_language, lldb::addr_t offset, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
        """
    def BreakpointCreateByRegex(self, *args):
        """
        BreakpointCreateByRegex(SBTarget self, char const * symbol_name_regex, char const * module_name=None) -> SBBreakpoint
        BreakpointCreateByRegex(SBTarget self, char const * symbol_name_regex, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
        BreakpointCreateByRegex(SBTarget self, char const * symbol_name_regex, lldb::LanguageType symbol_language, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
        """
    def BreakpointCreateBySourceRegex(self, *args):
        """
        BreakpointCreateBySourceRegex(SBTarget self, char const * source_regex, SBFileSpec source_file, char const * module_name=None) -> SBBreakpoint
        BreakpointCreateBySourceRegex(SBTarget self, char const * source_regex, SBFileSpecList module_list, SBFileSpecList source_file) -> SBBreakpoint
        BreakpointCreateBySourceRegex(SBTarget self, char const * source_regex, SBFileSpecList module_list, SBFileSpecList source_file, SBStringList func_names) -> SBBreakpoint
        """
    def BreakpointCreateForException(self, language, catch_bp, throw_bp):
        """BreakpointCreateForException(SBTarget self, lldb::LanguageType language, bool catch_bp, bool throw_bp) -> SBBreakpoint"""
    def BreakpointCreateByAddress(self, address):
        """BreakpointCreateByAddress(SBTarget self, lldb::addr_t address) -> SBBreakpoint"""
    def BreakpointCreateBySBAddress(self, address):
        """BreakpointCreateBySBAddress(SBTarget self, SBAddress address) -> SBBreakpoint"""
    def BreakpointCreateFromScript(self, class_name, extra_args, module_list, file_list, request_hardware: bool = False):
        """
        BreakpointCreateFromScript(SBTarget self, char const * class_name, SBStructuredData extra_args, SBFileSpecList module_list, SBFileSpecList file_list, bool request_hardware=False) -> SBBreakpoint

            Create a breakpoint using a scripted resolver.

            @param[in] class_name
               This is the name of the class that implements a scripted resolver.
               The class should have the following signature: ::

                   class Resolver:
                       def __init__(self, bkpt, extra_args):
                           # bkpt - the breakpoint for which this is the resolver.  When
                           # the resolver finds an interesting address, call AddLocation
                           # on this breakpoint to add it.
                           #
                           # extra_args - an SBStructuredData that can be used to
                           # parametrize this instance.  Same as the extra_args passed
                           # to BreakpointCreateFromScript.

                       def __get_depth__ (self):
                           # This is optional, but if defined, you should return the
                           # depth at which you want the callback to be called.  The
                           # available options are:
                           #    lldb.eSearchDepthModule
                           #    lldb.eSearchDepthCompUnit
                           # The default if you don't implement this method is
                           # eSearchDepthModule.

                       def __callback__(self, sym_ctx):
                           # sym_ctx - an SBSymbolContext that is the cursor in the
                           # search through the program to resolve breakpoints.
                           # The sym_ctx will be filled out to the depth requested in
                           # __get_depth__.
                           # Look in this sym_ctx for new breakpoint locations,
                           # and if found use bkpt.AddLocation to add them.
                           # Note, you will only get called for modules/compile_units that
                           # pass the SearchFilter provided by the module_list & file_list
                           # passed into BreakpointCreateFromScript.

                       def get_short_help(self):
                           # Optional, but if implemented return a short string that will
                           # be printed at the beginning of the break list output for the
                           # breakpoint.

            @param[in] extra_args
               This is an SBStructuredData object that will get passed to the
               constructor of the class in class_name.  You can use this to
               reuse the same class, parametrizing it with entries from this
               dictionary.

            @param module_list
               If this is non-empty, this will be used as the module filter in the
               SearchFilter created for this breakpoint.

            @param file_list
               If this is non-empty, this will be used as the comp unit filter in the
               SearchFilter created for this breakpoint.

            @return
                An SBBreakpoint that will set locations based on the logic in the
                resolver's search callback.
        """
    def BreakpointsCreateFromFile(self, *args):
        """
        BreakpointsCreateFromFile(SBTarget self, SBFileSpec source_file, SBBreakpointList new_bps) -> SBError
        BreakpointsCreateFromFile(SBTarget self, SBFileSpec source_file, SBStringList matching_names, SBBreakpointList new_bps) -> SBError

            Read breakpoints from source_file and return the newly created
            breakpoints in bkpt_list.

            @param[in] source_file
               The file from which to read the breakpoints

            @param[in] matching_names
               Only read in breakpoints whose names match one of the names in this
               list.

            @param[out] bkpt_list
               A list of the newly created breakpoints.

            @return
                An SBError detailing any errors in reading in the breakpoints.
        """
    def BreakpointsWriteToFile(self, *args):
        """
        BreakpointsWriteToFile(SBTarget self, SBFileSpec dest_file) -> SBError
        BreakpointsWriteToFile(SBTarget self, SBFileSpec dest_file, SBBreakpointList bkpt_list, bool append=False) -> SBError

            Write breakpoints listed in bkpt_list to dest_file.

            @param[in] dest_file
               The file to which to write the breakpoints.

            @param[in] bkpt_list
               Only write breakpoints from this list.

            @param[in] append
               If true, append the breakpoints in bkpt_list to the others
               serialized in dest_file.  If dest_file doesn't exist, then a new
               file will be created and the breakpoints in bkpt_list written to it.

            @return
                An SBError detailing any errors in writing in the breakpoints.
        """
    def GetNumBreakpoints(self):
        """GetNumBreakpoints(SBTarget self) -> uint32_t"""
    def GetBreakpointAtIndex(self, idx):
        """GetBreakpointAtIndex(SBTarget self, uint32_t idx) -> SBBreakpoint"""
    def BreakpointDelete(self, break_id):
        """BreakpointDelete(SBTarget self, lldb::break_id_t break_id) -> bool"""
    def FindBreakpointByID(self, break_id):
        """FindBreakpointByID(SBTarget self, lldb::break_id_t break_id) -> SBBreakpoint"""
    def FindBreakpointsByName(self, name, bkpt_list):
        """FindBreakpointsByName(SBTarget self, char const * name, SBBreakpointList bkpt_list) -> bool"""
    def GetBreakpointNames(self, names):
        """GetBreakpointNames(SBTarget self, SBStringList names)"""
    def DeleteBreakpointName(self, name):
        """DeleteBreakpointName(SBTarget self, char const * name)"""
    def EnableAllBreakpoints(self):
        """EnableAllBreakpoints(SBTarget self) -> bool"""
    def DisableAllBreakpoints(self):
        """DisableAllBreakpoints(SBTarget self) -> bool"""
    def DeleteAllBreakpoints(self):
        """DeleteAllBreakpoints(SBTarget self) -> bool"""
    def GetNumWatchpoints(self):
        """GetNumWatchpoints(SBTarget self) -> uint32_t"""
    def GetWatchpointAtIndex(self, idx):
        """GetWatchpointAtIndex(SBTarget self, uint32_t idx) -> SBWatchpoint"""
    def DeleteWatchpoint(self, watch_id):
        """DeleteWatchpoint(SBTarget self, lldb::watch_id_t watch_id) -> bool"""
    def FindWatchpointByID(self, watch_id):
        """FindWatchpointByID(SBTarget self, lldb::watch_id_t watch_id) -> SBWatchpoint"""
    def WatchAddress(self, addr, size, read, modify, error):
        """WatchAddress(SBTarget self, lldb::addr_t addr, size_t size, bool read, bool modify, SBError error) -> SBWatchpoint"""
    def WatchpointCreateByAddress(self, addr, size, options, error):
        """WatchpointCreateByAddress(SBTarget self, lldb::addr_t addr, size_t size, SBWatchpointOptions options, SBError error) -> SBWatchpoint"""
    def EnableAllWatchpoints(self):
        """EnableAllWatchpoints(SBTarget self) -> bool"""
    def DisableAllWatchpoints(self):
        """DisableAllWatchpoints(SBTarget self) -> bool"""
    def DeleteAllWatchpoints(self):
        """DeleteAllWatchpoints(SBTarget self) -> bool"""
    def GetBroadcaster(self):
        """GetBroadcaster(SBTarget self) -> SBBroadcaster"""
    def FindFirstType(self, type):
        """FindFirstType(SBTarget self, char const * type) -> SBType"""
    def FindTypes(self, type):
        """FindTypes(SBTarget self, char const * type) -> SBTypeList"""
    def GetBasicType(self, type):
        """GetBasicType(SBTarget self, lldb::BasicType type) -> SBType"""
    def CreateValueFromAddress(self, name, addr, type):
        """
        CreateValueFromAddress(SBTarget self, char const * name, SBAddress addr, SBType type) -> SBValue

            Create an SBValue with the given name by treating the memory starting at addr as an entity of type.

            @param[in] name
                The name of the resultant SBValue

            @param[in] addr
                The address of the start of the memory region to be used.

            @param[in] type
                The type to use to interpret the memory starting at addr.

            @return
                An SBValue of the given type, may be invalid if there was an error reading
                the underlying memory.
        """
    def CreateValueFromData(self, name, data, type):
        """CreateValueFromData(SBTarget self, char const * name, SBData data, SBType type) -> SBValue"""
    def CreateValueFromExpression(self, name, expr):
        """CreateValueFromExpression(SBTarget self, char const * name, char const * expr) -> SBValue"""
    def GetSourceManager(self):
        """GetSourceManager(SBTarget self) -> SBSourceManager"""
    def ReadInstructions(self, *args):
        """
        ReadInstructions(SBTarget self, SBAddress base_addr, uint32_t count) -> SBInstructionList
        ReadInstructions(SBTarget self, SBAddress base_addr, uint32_t count, char const * flavor_string) -> SBInstructionList

            Disassemble a specified number of instructions starting at an address.

            :param base_addr: the address to start disassembly from.
            :param count: the number of instructions to disassemble.
            :param flavor_string: may be 'intel' or 'att' on x86 targets to specify that style of disassembly.
            :rtype: SBInstructionList

        """
    def GetInstructions(self, base_addr, buf):
        """
        GetInstructions(SBTarget self, SBAddress base_addr, void const * buf) -> SBInstructionList

            Disassemble the bytes in a buffer and return them in an SBInstructionList.

            :param base_addr: used for symbolicating the offsets in the byte stream when disassembling.
            :param buf: bytes to be disassembled.
            :param size: (C++) size of the buffer.
            :rtype: SBInstructionList

        """
    def GetInstructionsWithFlavor(self, base_addr, flavor_string, buf):
        """
        GetInstructionsWithFlavor(SBTarget self, SBAddress base_addr, char const * flavor_string, void const * buf) -> SBInstructionList

            Disassemble the bytes in a buffer and return them in an SBInstructionList, with a supplied flavor.

            :param base_addr: used for symbolicating the offsets in the byte stream when disassembling.
            :param flavor:  may be 'intel' or 'att' on x86 targets to specify that style of disassembly.
            :param buf: bytes to be disassembled.
            :param size: (C++) size of the buffer.
            :rtype: SBInstructionList

        """
    def FindSymbols(self, *args):
        """FindSymbols(SBTarget self, char const * name, lldb::SymbolType type=eSymbolTypeAny) -> SBSymbolContextList"""
    def __eq__(self, rhs):
        """__eq__(SBTarget self, SBTarget rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBTarget self, SBTarget rhs) -> bool"""
    def GetDescription(self, description, description_level):
        """GetDescription(SBTarget self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
    def EvaluateExpression(self, *args):
        """
        EvaluateExpression(SBTarget self, char const * expr) -> SBValue
        EvaluateExpression(SBTarget self, char const * expr, SBExpressionOptions options) -> SBValue
        """
    def GetStackRedZoneSize(self):
        """GetStackRedZoneSize(SBTarget self) -> lldb::addr_t"""
    def IsLoaded(self, module):
        """
        IsLoaded(SBTarget self, SBModule module) -> bool

            Returns true if the module has been loaded in this `SBTarget`.
            A module can be loaded either by the dynamic loader or by being manually
            added to the target (see `SBTarget.AddModule` and the ``target module add`` command).

            :rtype: bool

        """
    def GetLaunchInfo(self):
        """GetLaunchInfo(SBTarget self) -> SBLaunchInfo"""
    def SetLaunchInfo(self, launch_info):
        """SetLaunchInfo(SBTarget self, SBLaunchInfo launch_info)"""
    def GetTrace(self):
        """GetTrace(SBTarget self) -> SBTrace"""
    def CreateTrace(self, error):
        """CreateTrace(SBTarget self, SBError error) -> SBTrace"""
    def __eq__(self, other): ...
    class modules_access:
        """A helper object that will lazily hand out lldb.SBModule objects for a target when supplied an index, or by full or partial path."""
        sbtarget: Incomplete
        def __init__(self, sbtarget) -> None: ...
        def __len__(self) -> int: ...
        def __getitem__(self, key): ...
    def get_modules_access_object(self):
        """An accessor function that returns a modules_access() object which allows lazy module access from a lldb.SBTarget object."""
    def get_modules_array(self):
        """An accessor function that returns a list() that contains all modules in a lldb.SBTarget object."""
    def module_iter(self):
        """Returns an iterator over all modules in a lldb.SBTarget
        object."""
    def breakpoint_iter(self):
        """Returns an iterator over all breakpoints in a lldb.SBTarget
        object."""
    class bkpts_access:
        """A helper object that will lazily hand out bkpts for a target when supplied an index."""
        sbtarget: Incomplete
        def __init__(self, sbtarget) -> None: ...
        def __len__(self) -> int: ...
        def __getitem__(self, key): ...
    def get_bkpts_access_object(self):
        """An accessor function that returns a bkpts_access() object which allows lazy bkpt access from a lldb.SBtarget object."""
    def get_target_bkpts(self):
        """An accessor function that returns a list() that contains all bkpts in a lldb.SBtarget object."""
    def watchpoint_iter(self):
        """Returns an iterator over all watchpoints in a lldb.SBTarget
        object."""
    class watchpoints_access:
        """A helper object that will lazily hand out watchpoints for a target when supplied an index."""
        sbtarget: Incomplete
        def __init__(self, sbtarget) -> None: ...
        def __len__(self) -> int: ...
        def __getitem__(self, key): ...
    def get_watchpoints_access_object(self):
        """An accessor function that returns a watchpoints_access() object which allows lazy watchpoint access from a lldb.SBtarget object."""
    def get_target_watchpoints(self):
        """An accessor function that returns a list() that contains all watchpoints in a lldb.SBtarget object."""
    modules: Incomplete
    module: Incomplete
    process: Incomplete
    executable: Incomplete
    debugger: Incomplete
    num_breakpoints: Incomplete
    breakpoints: Incomplete
    breakpoint: Incomplete
    num_watchpoints: Incomplete
    watchpoints: Incomplete
    watchpoint: Incomplete
    broadcaster: Incomplete
    byte_order: Incomplete
    addr_size: Incomplete
    triple: Incomplete
    data_byte_size: Incomplete
    code_byte_size: Incomplete
    platform: Incomplete
    def __eq__(self, rhs): ...
    def __ne__(self, rhs): ...

class SBThread:
    """
    Represents a thread of execution. :py:class:`SBProcess` contains SBThread(s).

    SBThreads can be referred to by their ID, which maps to the system specific thread
    identifier, or by IndexID.  The ID may or may not be unique depending on whether the
    system reuses its thread identifiers.  The IndexID is a monotonically increasing identifier
    that will always uniquely reference a particular thread, and when that thread goes
    away it will not be reused.

    SBThread supports frame iteration. For example (from test/python_api/
    lldbutil/iter/TestLLDBIterator.py), ::

            from lldbutil import print_stacktrace
            stopped_due_to_breakpoint = False
            for thread in process:
                if self.TraceOn():
                    print_stacktrace(thread)
                ID = thread.GetThreadID()
                if thread.GetStopReason() == lldb.eStopReasonBreakpoint:
                    stopped_due_to_breakpoint = True
                for frame in thread:
                    self.assertTrue(frame.GetThread().GetThreadID() == ID)
                    if self.TraceOn():
                        print frame

            self.assertTrue(stopped_due_to_breakpoint)

    See also :py:class:`SBFrame` .
    """
    thisown: Incomplete
    eBroadcastBitStackChanged: Incomplete
    eBroadcastBitThreadSuspended: Incomplete
    eBroadcastBitThreadResumed: Incomplete
    eBroadcastBitSelectedFrameChanged: Incomplete
    eBroadcastBitThreadSelected: Incomplete
    @staticmethod
    def GetBroadcasterClassName():
        """GetBroadcasterClassName() -> char const *"""
    def __init__(self, *args) -> None:
        """
        __init__(SBThread self) -> SBThread
        __init__(SBThread self, SBThread thread) -> SBThread
        """
    __swig_destroy__: Incomplete
    def GetQueue(self):
        """

        Return the SBQueue for this thread.  If this thread is not currently associated
        with a libdispatch queue, the SBQueue object's IsValid() method will return false.
        If this SBThread is actually a HistoryThread, we may be able to provide QueueID
        and QueueName, but not provide an SBQueue.  Those individual attributes may have
        been saved for the HistoryThread without enough information to reconstitute the
        entire SBQueue at that time.
        This method takes no arguments, returns an SBQueue.
        """
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBThread self) -> bool"""
    def Clear(self):
        """Clear(SBThread self)"""
    def GetStopReason(self):
        """GetStopReason(SBThread self) -> lldb::StopReason"""
    def GetStopReasonDataCount(self):
        """
        GetStopReasonDataCount(SBThread self) -> size_t

            Get the number of words associated with the stop reason.
            See also GetStopReasonDataAtIndex().
        """
    def GetStopReasonDataAtIndex(self, idx):
        """
        GetStopReasonDataAtIndex(SBThread self, uint32_t idx) -> uint64_t

            Get information associated with a stop reason.

            Breakpoint stop reasons will have data that consists of pairs of
            breakpoint IDs followed by the breakpoint location IDs (they always come
            in pairs).

            Stop Reason              Count Data Type
            ======================== ===== =========================================
            eStopReasonNone          0
            eStopReasonTrace         0
            eStopReasonBreakpoint    N     duple: {breakpoint id, location id}
            eStopReasonWatchpoint    1     watchpoint id
            eStopReasonSignal        1     unix signal number
            eStopReasonException     N     exception data
            eStopReasonExec          0
            eStopReasonFork          1     pid of the child process
            eStopReasonVFork         1     pid of the child process
            eStopReasonVForkDone     0
            eStopReasonPlanComplete  0
        """
    def GetStopReasonExtendedInfoAsJSON(self, stream):
        """

        Collects a thread's stop reason extended information dictionary and prints it
        into the SBStream in a JSON format. The format of this JSON dictionary depends
        on the stop reason and is currently used only for instrumentation plugins.
        """
    def GetStopReasonExtendedBacktraces(self, type):
        """

        Returns a collection of historical stack traces that are significant to the
        current stop reason. Used by ThreadSanitizer, where we provide various stack
        traces that were involved in a data race or other type of detected issue.
        """
    def GetStopDescription(self, dst_or_null):
        """

        Pass only an (int)length and expect to get a Python string describing the
        stop reason.
        """
    def GetStopReturnValue(self):
        """GetStopReturnValue(SBThread self) -> SBValue"""
    def GetThreadID(self):
        """

        Returns a unique thread identifier (type lldb::tid_t, typically a 64-bit type)
        for the current SBThread that will remain constant throughout the thread's
        lifetime in this process and will not be reused by another thread during this
        process lifetime.  On Mac OS X systems, this is a system-wide unique thread
        identifier; this identifier is also used by other tools like sample which helps
        to associate data from those tools with lldb.  See related GetIndexID.
        """
    def GetIndexID(self):
        """

        Return the index number for this SBThread.  The index number is the same thing
        that a user gives as an argument to 'thread select' in the command line lldb.
        These numbers start at 1 (for the first thread lldb sees in a debug session)
        and increments up throughout the process lifetime.  An index number will not be
        reused for a different thread later in a process - thread 1 will always be
        associated with the same thread.  See related GetThreadID.
        This method returns a uint32_t index number, takes no arguments.
        """
    def GetName(self):
        """GetName(SBThread self) -> char const *"""
    def GetQueueName(self):
        """

        Return the queue name associated with this thread, if any, as a str.
        For example, with a libdispatch (aka Grand Central Dispatch) queue.
        """
    def GetQueueID(self):
        """

        Return the dispatch_queue_id for this thread, if any, as a lldb::queue_id_t.
        For example, with a libdispatch (aka Grand Central Dispatch) queue.
        """
    def GetInfoItemByPathAsString(self, path, strm):
        """
        GetInfoItemByPathAsString(SBThread self, char const * path, SBStream strm) -> bool

            Takes a path string and a SBStream reference as parameters, returns a bool.
            Collects the thread's 'info' dictionary from the remote system, uses the path
            argument to descend into the dictionary to an item of interest, and prints
            it into the SBStream in a natural format.  Return bool is to indicate if
            anything was printed into the stream (true) or not (false).
        """
    def StepOver(self, *args):
        """
        StepOver(SBThread self, lldb::RunMode stop_other_threads=eOnlyDuringStepping)
        StepOver(SBThread self, lldb::RunMode stop_other_threads, SBError error)
        Do a source level single step over in the currently selected thread.
        """
    def StepInto(self, *args):
        """
        StepInto(SBThread self, lldb::RunMode stop_other_threads=eOnlyDuringStepping)
        StepInto(SBThread self, char const * target_name, lldb::RunMode stop_other_threads=eOnlyDuringStepping)
        StepInto(SBThread self, char const * target_name, uint32_t end_line, SBError error, lldb::RunMode stop_other_threads=eOnlyDuringStepping)

            Step the current thread from the current source line to the line given by end_line, stopping if
            the thread steps into the function given by target_name.  If target_name is None, then stepping will stop
            in any of the places we would normally stop.
        """
    def StepOut(self, *args):
        """
        StepOut(SBThread self)
        StepOut(SBThread self, SBError error)
        Step out of the currently selected thread.
        """
    def StepOutOfFrame(self, *args):
        """
        StepOutOfFrame(SBThread self, SBFrame frame)
        StepOutOfFrame(SBThread self, SBFrame frame, SBError error)
        Step out of the specified frame.
        """
    def StepInstruction(self, *args):
        """
        StepInstruction(SBThread self, bool step_over)
        StepInstruction(SBThread self, bool step_over, SBError error)
        Do an instruction level single step in the currently selected thread.
        """
    def StepOverUntil(self, frame, file_spec, line):
        """StepOverUntil(SBThread self, SBFrame frame, SBFileSpec file_spec, uint32_t line) -> SBError"""
    def StepUsingScriptedThreadPlan(self, *args):
        """
        StepUsingScriptedThreadPlan(SBThread self, char const * script_class_name) -> SBError
        StepUsingScriptedThreadPlan(SBThread self, char const * script_class_name, bool resume_immediately) -> SBError
        StepUsingScriptedThreadPlan(SBThread self, char const * script_class_name, SBStructuredData args_data, bool resume_immediately) -> SBError
        """
    def JumpToLine(self, file_spec, line):
        """JumpToLine(SBThread self, SBFileSpec file_spec, uint32_t line) -> SBError"""
    def RunToAddress(self, *args):
        """
        RunToAddress(SBThread self, lldb::addr_t addr)
        RunToAddress(SBThread self, lldb::addr_t addr, SBError error)
        """
    def ReturnFromFrame(self, frame, return_value):
        """

        Force a return from the frame passed in (and any frames younger than it)
        without executing any more code in those frames.  If return_value contains
        a valid SBValue, that will be set as the return value from frame.  Note, at
        present only scalar return values are supported.
        """
    def UnwindInnermostExpression(self):
        """

        Unwind the stack frames from the innermost expression evaluation.
        This API is equivalent to 'thread return -x'.
        """
    def Suspend(self, *args):
        """
        Suspend(SBThread self) -> bool
        Suspend(SBThread self, SBError error) -> bool

            LLDB currently supports process centric debugging which means when any
            thread in a process stops, all other threads are stopped. The Suspend()
            call here tells our process to suspend a thread and not let it run when
            the other threads in a process are allowed to run. So when
            SBProcess::Continue() is called, any threads that aren't suspended will
            be allowed to run. If any of the SBThread functions for stepping are
            called (StepOver, StepInto, StepOut, StepInstruction, RunToAddres), the
            thread will now be allowed to run and these functions will simply return.

            Eventually we plan to add support for thread centric debugging where
            each thread is controlled individually and each thread would broadcast
            its state, but we haven't implemented this yet.

            Likewise the SBThread::Resume() call will again allow the thread to run
            when the process is continued.

            Suspend() and Resume() functions are not currently reference counted, if
            anyone has the need for them to be reference counted, please let us
            know.
        """
    def Resume(self, *args):
        """
        Resume(SBThread self) -> bool
        Resume(SBThread self, SBError error) -> bool
        """
    def IsSuspended(self):
        """IsSuspended(SBThread self) -> bool"""
    def IsStopped(self):
        """IsStopped(SBThread self) -> bool"""
    def GetNumFrames(self):
        """GetNumFrames(SBThread self) -> uint32_t"""
    def GetFrameAtIndex(self, idx):
        """GetFrameAtIndex(SBThread self, uint32_t idx) -> SBFrame"""
    def GetSelectedFrame(self):
        """GetSelectedFrame(SBThread self) -> SBFrame"""
    def SetSelectedFrame(self, frame_idx):
        """SetSelectedFrame(SBThread self, uint32_t frame_idx) -> SBFrame"""
    @staticmethod
    def EventIsThreadEvent(event):
        """EventIsThreadEvent(SBEvent event) -> bool"""
    @staticmethod
    def GetStackFrameFromEvent(event):
        """GetStackFrameFromEvent(SBEvent event) -> SBFrame"""
    @staticmethod
    def GetThreadFromEvent(event):
        """GetThreadFromEvent(SBEvent event) -> SBThread"""
    def GetProcess(self):
        """GetProcess(SBThread self) -> SBProcess"""
    def __eq__(self, rhs):
        """__eq__(SBThread self, SBThread rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBThread self, SBThread rhs) -> bool"""
    def GetDescription(self, *args):
        """
        GetDescription(SBThread self, SBStream description) -> bool
        GetDescription(SBThread self, SBStream description, bool stop_format) -> bool

            Get the description strings for this thread that match what the
            lldb driver will present, using the thread-format (stop_format==false)
            or thread-stop-format (stop_format = true).
        """
    def GetDescriptionWithFormat(self, format, output):
        """GetDescriptionWithFormat(SBThread self, SBFormat format, SBStream output) -> SBError"""
    def GetStatus(self, status):
        """GetStatus(SBThread self, SBStream status) -> bool"""
    def GetExtendedBacktraceThread(self, type):
        """

        Given an argument of str to specify the type of thread-origin extended
        backtrace to retrieve, query whether the origin of this thread is
        available.  An SBThread is retured; SBThread.IsValid will return true
        if an extended backtrace was available.  The returned SBThread is not
        a part of the SBProcess' thread list and it cannot be manipulated like
        normal threads -- you cannot step or resume it, for instance -- it is
        intended to used primarily for generating a backtrace.  You may request
        the returned thread's own thread origin in turn.
        """
    def GetExtendedBacktraceOriginatingIndexID(self):
        """

        Takes no arguments, returns a uint32_t.
        If this SBThread is an ExtendedBacktrace thread, get the IndexID of the
        original thread that this ExtendedBacktrace thread represents, if
        available.  The thread that was running this backtrace in the past may
        not have been registered with lldb's thread index (if it was created,
        did its work, and was destroyed without lldb ever stopping execution).
        In that case, this ExtendedBacktrace thread's IndexID will be returned.
        """
    def GetCurrentException(self):
        """

        Returns an SBValue object represeting the current exception for the thread,
        if there is any. Currently, this works for Obj-C code and returns an SBValue
        representing the NSException object at the throw site or that's currently
        being processes.
        """
    def GetCurrentExceptionBacktrace(self):
        """

        Returns a historical (fake) SBThread representing the stack trace of an
        exception, if there is one for the thread. Currently, this works for Obj-C
        code, and can retrieve the throw-site backtrace of an NSException object
        even when the program is no longer at the throw site.
        """
    def SafeToCallFunctions(self):
        """

        Takes no arguments, returns a bool.
        lldb may be able to detect that function calls should not be executed
        on a given thread at a particular point in time.  It is recommended that
        this is checked before performing an inferior function call on a given
        thread.
        """
    def GetSiginfo(self):
        """

        Retruns a SBValue object representing the siginfo for the current signal.

        """
    def __eq__(self, other): ...
    def __iter__(self):
        """Iterate over all frames in a lldb.SBThread object."""
    def __len__(self) -> int:
        """Return the number of frames in a lldb.SBThread object."""
    class frames_access:
        """A helper object that will lazily hand out frames for a thread when supplied an index."""
        sbthread: Incomplete
        def __init__(self, sbthread) -> None: ...
        def __len__(self) -> int: ...
        def __getitem__(self, key): ...
    def get_frames_access_object(self):
        """An accessor function that returns a frames_access() object which allows lazy frame access from a lldb.SBThread object."""
    def get_thread_frames(self):
        """An accessor function that returns a list() that contains all frames in a lldb.SBThread object."""
    id: Incomplete
    idx: Incomplete
    return_value: Incomplete
    process: Incomplete
    num_frames: Incomplete
    frames: Incomplete
    frame: Incomplete
    name: Incomplete
    queue: Incomplete
    queue_id: Incomplete
    stop_reason: Incomplete
    is_suspended: Incomplete
    is_stopped: Incomplete
    def __eq__(self, rhs): ...
    def __ne__(self, rhs): ...

class SBThreadCollection:
    """Represents a collection of SBThread objects."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBThreadCollection self) -> SBThreadCollection
        __init__(SBThreadCollection self, SBThreadCollection rhs) -> SBThreadCollection
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBThreadCollection self) -> bool"""
    def GetSize(self):
        """GetSize(SBThreadCollection self) -> size_t"""
    def GetThreadAtIndex(self, idx):
        """GetThreadAtIndex(SBThreadCollection self, size_t idx) -> SBThread"""
    def __iter__(self):
        """Iterate over all threads in a lldb.SBThreadCollection object."""
    def __len__(self) -> int:
        """Return the number of threads in a lldb.SBThreadCollection object."""

class SBThreadPlan:
    """
    Represents a plan for the execution control of a given thread.

    See also :py:class:`SBThread` and :py:class:`SBFrame`.
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBThreadPlan self) -> SBThreadPlan
        __init__(SBThreadPlan self, SBThreadPlan threadPlan) -> SBThreadPlan
        __init__(SBThreadPlan self, SBThread thread, char const * class_name) -> SBThreadPlan
        __init__(SBThreadPlan self, SBThread thread, char const * class_name, SBStructuredData args_data) -> SBThreadPlan
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def Clear(self):
        """Clear(SBThreadPlan self)"""
    def GetStopReason(self):
        """GetStopReason(SBThreadPlan self) -> lldb::StopReason"""
    def GetStopReasonDataCount(self):
        """
        GetStopReasonDataCount(SBThreadPlan self) -> size_t

            Get the number of words associated with the stop reason.
            See also GetStopReasonDataAtIndex().
        """
    def GetStopReasonDataAtIndex(self, idx):
        """
        GetStopReasonDataAtIndex(SBThreadPlan self, uint32_t idx) -> uint64_t

            Get information associated with a stop reason.

            Breakpoint stop reasons will have data that consists of pairs of
            breakpoint IDs followed by the breakpoint location IDs (they always come
            in pairs).

            Stop Reason              Count Data Type
            ======================== ===== =========================================
            eStopReasonNone          0
            eStopReasonTrace         0
            eStopReasonBreakpoint    N     duple: {breakpoint id, location id}
            eStopReasonWatchpoint    1     watchpoint id
            eStopReasonSignal        1     unix signal number
            eStopReasonException     N     exception data
            eStopReasonExec          0
            eStopReasonFork          1     pid of the child process
            eStopReasonVFork         1     pid of the child process
            eStopReasonVForkDone     0
            eStopReasonPlanComplete  0
        """
    def GetThread(self):
        """GetThread(SBThreadPlan self) -> SBThread"""
    def GetDescription(self, description):
        """GetDescription(SBThreadPlan self, SBStream description) -> bool"""
    def SetPlanComplete(self, success):
        """SetPlanComplete(SBThreadPlan self, bool success)"""
    def IsPlanComplete(self):
        """IsPlanComplete(SBThreadPlan self) -> bool"""
    def IsPlanStale(self):
        """IsPlanStale(SBThreadPlan self) -> bool"""
    def IsValid(self, *args):
        """
        IsValid(SBThreadPlan self) -> bool
        IsValid(SBThreadPlan self) -> bool
        """
    def GetStopOthers(self):
        """
        GetStopOthers(SBThreadPlan self) -> bool
        Return whether this plan will ask to stop other threads when it runs.
        """
    def SetStopOthers(self, stop_others):
        """
        SetStopOthers(SBThreadPlan self, bool stop_others)
        Set whether this plan will ask to stop other threads when it runs.
        """
    def QueueThreadPlanForStepOverRange(self, *args):
        """
        QueueThreadPlanForStepOverRange(SBThreadPlan self, SBAddress start_address, lldb::addr_t range_size) -> SBThreadPlan
        QueueThreadPlanForStepOverRange(SBThreadPlan self, SBAddress start_address, lldb::addr_t range_size, SBError error) -> SBThreadPlan
        """
    def QueueThreadPlanForStepInRange(self, *args):
        """
        QueueThreadPlanForStepInRange(SBThreadPlan self, SBAddress start_address, lldb::addr_t range_size) -> SBThreadPlan
        QueueThreadPlanForStepInRange(SBThreadPlan self, SBAddress start_address, lldb::addr_t range_size, SBError error) -> SBThreadPlan
        """
    def QueueThreadPlanForStepOut(self, *args):
        """
        QueueThreadPlanForStepOut(SBThreadPlan self, uint32_t frame_idx_to_step_to, bool first_insn=False) -> SBThreadPlan
        QueueThreadPlanForStepOut(SBThreadPlan self, uint32_t frame_idx_to_step_to, bool first_insn, SBError error) -> SBThreadPlan
        """
    def QueueThreadPlanForRunToAddress(self, *args):
        """
        QueueThreadPlanForRunToAddress(SBThreadPlan self, SBAddress address) -> SBThreadPlan
        QueueThreadPlanForRunToAddress(SBThreadPlan self, SBAddress address, SBError error) -> SBThreadPlan
        """
    def QueueThreadPlanForStepScripted(self, *args):
        """
        QueueThreadPlanForStepScripted(SBThreadPlan self, char const * script_class_name) -> SBThreadPlan
        QueueThreadPlanForStepScripted(SBThreadPlan self, char const * script_class_name, SBError error) -> SBThreadPlan
        QueueThreadPlanForStepScripted(SBThreadPlan self, char const * script_class_name, SBStructuredData args_data, SBError error) -> SBThreadPlan
        """

class SBTrace:
    """Represents a processor trace."""
    thisown: Incomplete
    def __init__(self) -> None:
        """__init__(SBTrace self) -> SBTrace"""
    @staticmethod
    def LoadTraceFromFile(error, debugger, trace_description_file):
        """LoadTraceFromFile(SBError error, SBDebugger debugger, SBFileSpec trace_description_file) -> SBTrace"""
    def CreateNewCursor(self, error, thread):
        """CreateNewCursor(SBTrace self, SBError error, SBThread thread) -> SBTraceCursor"""
    def SaveToDisk(self, error, bundle_dir, compact: bool = False):
        """SaveToDisk(SBTrace self, SBError error, SBFileSpec bundle_dir, bool compact=False) -> SBFileSpec"""
    def GetStartConfigurationHelp(self):
        """GetStartConfigurationHelp(SBTrace self) -> char const *"""
    def Start(self, *args):
        """
        Start(SBTrace self, SBStructuredData configuration) -> SBError
        Start(SBTrace self, SBThread thread, SBStructuredData configuration) -> SBError
        """
    def Stop(self, *args):
        """
        Stop(SBTrace self) -> SBError
        Stop(SBTrace self, SBThread thread) -> SBError
        """
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBTrace self) -> bool"""
    __swig_destroy__: Incomplete

class SBTraceCursor:
    """Represents a trace cursor."""
    thisown: Incomplete
    def __init__(self) -> None:
        """__init__(SBTraceCursor self) -> SBTraceCursor"""
    def SetForwards(self, forwards):
        """SetForwards(SBTraceCursor self, bool forwards)"""
    def IsForwards(self):
        """IsForwards(SBTraceCursor self) -> bool"""
    def Next(self):
        """Next(SBTraceCursor self)"""
    def HasValue(self):
        """HasValue(SBTraceCursor self) -> bool"""
    def GoToId(self, id):
        """GoToId(SBTraceCursor self, lldb::user_id_t id) -> bool"""
    def HasId(self, id):
        """HasId(SBTraceCursor self, lldb::user_id_t id) -> bool"""
    def GetId(self):
        """GetId(SBTraceCursor self) -> lldb::user_id_t"""
    def Seek(self, offset, origin):
        """Seek(SBTraceCursor self, int64_t offset, lldb::TraceCursorSeekType origin) -> bool"""
    def GetItemKind(self):
        """GetItemKind(SBTraceCursor self) -> lldb::TraceItemKind"""
    def IsError(self):
        """IsError(SBTraceCursor self) -> bool"""
    def GetError(self):
        """GetError(SBTraceCursor self) -> char const *"""
    def IsEvent(self):
        """IsEvent(SBTraceCursor self) -> bool"""
    def GetEventType(self):
        """GetEventType(SBTraceCursor self) -> lldb::TraceEvent"""
    def GetEventTypeAsString(self):
        """GetEventTypeAsString(SBTraceCursor self) -> char const *"""
    def IsInstruction(self):
        """IsInstruction(SBTraceCursor self) -> bool"""
    def GetLoadAddress(self):
        """GetLoadAddress(SBTraceCursor self) -> lldb::addr_t"""
    def GetCPU(self):
        """GetCPU(SBTraceCursor self) -> lldb::cpu_id_t"""
    def IsValid(self):
        """IsValid(SBTraceCursor self) -> bool"""
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    __swig_destroy__: Incomplete

class SBTypeMember:
    """Represents a member of a type."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBTypeMember self) -> SBTypeMember
        __init__(SBTypeMember self, SBTypeMember rhs) -> SBTypeMember
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBTypeMember self) -> bool"""
    def GetName(self):
        """GetName(SBTypeMember self) -> char const *"""
    def GetType(self):
        """GetType(SBTypeMember self) -> SBType"""
    def GetOffsetInBytes(self):
        """GetOffsetInBytes(SBTypeMember self) -> uint64_t"""
    def GetOffsetInBits(self):
        """GetOffsetInBits(SBTypeMember self) -> uint64_t"""
    def IsBitfield(self):
        """IsBitfield(SBTypeMember self) -> bool"""
    def GetBitfieldSizeInBits(self):
        """GetBitfieldSizeInBits(SBTypeMember self) -> uint32_t"""
    def GetDescription(self, description, description_level):
        """GetDescription(SBTypeMember self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
    def __eq__(self, other): ...
    name: Incomplete
    type: Incomplete
    byte_offset: Incomplete
    bit_offset: Incomplete
    is_bitfield: Incomplete
    bitfield_bit_size: Incomplete

class SBTypeMemberFunction:
    """Represents a member function of a type."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBTypeMemberFunction self) -> SBTypeMemberFunction
        __init__(SBTypeMemberFunction self, SBTypeMemberFunction rhs) -> SBTypeMemberFunction
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBTypeMemberFunction self) -> bool"""
    def GetName(self):
        """GetName(SBTypeMemberFunction self) -> char const *"""
    def GetDemangledName(self):
        """GetDemangledName(SBTypeMemberFunction self) -> char const *"""
    def GetMangledName(self):
        """GetMangledName(SBTypeMemberFunction self) -> char const *"""
    def GetType(self):
        """GetType(SBTypeMemberFunction self) -> SBType"""
    def GetReturnType(self):
        """GetReturnType(SBTypeMemberFunction self) -> SBType"""
    def GetNumberOfArguments(self):
        """GetNumberOfArguments(SBTypeMemberFunction self) -> uint32_t"""
    def GetArgumentTypeAtIndex(self, arg2):
        """GetArgumentTypeAtIndex(SBTypeMemberFunction self, uint32_t arg2) -> SBType"""
    def GetKind(self):
        """GetKind(SBTypeMemberFunction self) -> lldb::MemberFunctionKind"""
    def GetDescription(self, description, description_level):
        """GetDescription(SBTypeMemberFunction self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
    def __eq__(self, other): ...

class SBType:
    """
    Represents a data type in lldb.

    The actual characteristics of each type are defined by the semantics of the
    programming language and the specific language implementation that was used
    to compile the target program. See the language-specific notes in the
    documentation of each method.

    SBType instances can be obtained by a variety of methods.
    `SBTarget.FindFirstType` and `SBModule.FindFirstType` can be used to create
    `SBType` representations of types in executables/libraries with debug
    information. For some languages such as C, C++ and Objective-C it is possible
    to create new types by evaluating expressions that define a new type.

    Note that most `SBType` properties are computed independently of any runtime
    information so for dynamic languages the functionality can be very limited.
    `SBValue` can be used to represent runtime values which then can be more
    accurately queried for certain information such as byte size.


    SBType supports the eq/ne operator. For example,::

        //main.cpp:

        class Task {
        public:
            int id;
            Task *next;
            Task(int i, Task *n):
                id(i),
                next(n)
            {}
        };

        int main (int argc, char const *argv[])
        {
            Task *task_head = new Task(-1, NULL);
            Task *task1 = new Task(1, NULL);
            Task *task2 = new Task(2, NULL);
            Task *task3 = new Task(3, NULL); // Orphaned.
            Task *task4 = new Task(4, NULL);
            Task *task5 = new Task(5, NULL);

            task_head->next = task1;
            task1->next = task2;
            task2->next = task4;
            task4->next = task5;

            int total = 0;
            Task *t = task_head;
            while (t != NULL) {
                if (t->id >= 0)
                    ++total;
                t = t->next;
            }
            printf('We have a total number of %d tasks\\n', total);

            // This corresponds to an empty task list.
            Task *empty_task_head = new Task(-1, NULL);

            return 0; // Break at this line
        }

        # find_type.py:

                # Get the type 'Task'.
                task_type = target.FindFirstType('Task')
                self.assertTrue(task_type)

                # Get the variable 'task_head'.
                frame0.FindVariable('task_head')
                task_head_type = task_head.GetType()
                self.assertTrue(task_head_type.IsPointerType())

                # task_head_type is 'Task *'.
                task_pointer_type = task_type.GetPointerType()
                self.assertTrue(task_head_type == task_pointer_type)

                # Get the child mmember 'id' from 'task_head'.
                id = task_head.GetChildMemberWithName('id')
                id_type = id.GetType()

                # SBType.GetBasicType() takes an enum 'BasicType' (lldb-enumerations.h).
                int_type = id_type.GetBasicType(lldb.eBasicTypeInt)
                # id_type and int_type should be the same type!
                self.assertTrue(id_type == int_type)


    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBType self) -> SBType
        __init__(SBType self, SBType rhs) -> SBType
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBType self) -> bool"""
    def GetByteSize(self):
        """
        GetByteSize(SBType self) -> uint64_t
        Returns the number of bytes a variable with the given types occupies in memory.

            Returns ``0`` if the size can't be determined.

            If a type occupies ``N`` bytes + ``M`` bits in memory, this function returns
            the rounded up amount of bytes (i.e., if ``M`` is ``0``,
            this function returns ``N`` and otherwise ``N + 1``).

            Language-specific behaviour:

            * C: The output is expected to match the value of ``sizeof(Type)``. If
              ``sizeof(Type)`` is not a valid expression for the given type, the
              function returns ``0``.
            * C++: Same as in C.
            * Objective-C: Same as in C. For Objective-C classes this always returns
              ``0`` as the actual size depends on runtime information.

        """
    def IsPointerType(self):
        """
        IsPointerType(SBType self) -> bool
        Returns true if this type is a pointer type.

            Language-specific behaviour:

            * C: Returns true for C pointer types (or typedefs of these types).
            * C++: Pointer types include the C pointer types as well as pointers to data
              mebers or member functions.
            * Objective-C: Pointer types include the C pointer types. ``id``, ``Class``
              and pointers to blocks are also considered pointer types.

        """
    def IsReferenceType(self):
        """
        IsReferenceType(SBType self) -> bool
        Returns true if this type is a reference type.

            Language-specific behaviour:

            * C: Returns false for all types.
            * C++: Both l-value and r-value references are considered reference types.
            * Objective-C: Returns false for all types.

        """
    def IsFunctionType(self):
        """IsFunctionType(SBType self) -> bool"""
    def IsPolymorphicClass(self):
        """
        IsPolymorphicClass(SBType self) -> bool
        Returns true if this type is a polymorphic type.

            Language-specific behaviour:

            * C: Returns false for all types.
            * C++: Returns true if the type is a class type that contains at least one
              virtual member function or if at least one of its base classes is
              considered a polymorphic type.
            * Objective-C: Returns false for all types.

        """
    def IsArrayType(self):
        """
        IsArrayType(SBType self) -> bool
        Returns true if this type is an array type.

            Language-specific behaviour:

            * C: Returns true if the types is an array type. This includes incomplete
              array types ``T[]`` and array types with integer (``T[1]``) or variable
              length (``T[some_variable]``). Pointer types are not considered arrays.
            * C++: Includes C's array types and dependent array types (i.e., array types
              in templates which size depends on template arguments).
            * Objective-C: Same as in C.

        """
    def IsVectorType(self):
        """
        IsVectorType(SBType self) -> bool
        Returns true if this type is a vector type.

            Language-specific behaviour:

            * C: Returns true if the types is a vector type created with
              GCC's ``vector_size`` or Clang's ``ext_vector_type`` feature.
            * C++: Same as in C.
            * Objective-C: Same as in C.

        """
    def IsTypedefType(self):
        """
        IsTypedefType(SBType self) -> bool
        Returns true if this type is a typedef.

            Language-specific behaviour:

            * C: Returns true if the type is a C typedef.
            * C++: Same as in C. Also treats type aliases as typedefs.
            * Objective-C: Same as in C.

        """
    def IsAnonymousType(self):
        """
        IsAnonymousType(SBType self) -> bool
        Returns true if this type is an anonymous type.

            Language-specific behaviour:

            * C: Returns true for anonymous unions. Also returns true for
              anonymous structs (which are a GNU language extension).
            * C++: Same as in C.
            * Objective-C: Same as in C.

        """
    def IsScopedEnumerationType(self):
        """
        IsScopedEnumerationType(SBType self) -> bool
        Returns true if this type is a scoped enum.

            Language-specific behaviour:

            * C: Returns false for all types.
            * C++: Return true only for C++11 scoped enums.
            * Objective-C: Returns false for all types.

        """
    def IsAggregateType(self):
        """
        IsAggregateType(SBType self) -> bool
        Returns true if this type is an aggregate type.

            Language-specific behaviour:

            * C: Returns true for struct values, arrays, and vectors.
            * C++: Same a C. Also includes class instances.
            * Objective-C: Same as C. Also includes class instances.

        """
    def GetPointerType(self) -> SBType:
        """
        GetPointerType(SBType self) -> SBType
        Returns a type that represents a pointer to this type.

            If the type system of the current language can't represent a pointer to this
            type or this type is invalid, an invalid `SBType` is returned.

            Language-specific behaviour:

            * C: Returns the pointer type of this type.
            * C++: Same as in C.
            * Objective-C: Same as in C.

        """
    def GetPointeeType(self) -> SBType:
        """
        GetPointeeType(SBType self) -> SBType
        Returns the underlying pointee type.

            If this type is a pointer type as specified by `IsPointerType` then this
            returns the underlying type. If this is not a pointer type or an invalid
            `SBType` then this returns an invalid `SBType`.

            Language-specific behaviour:

            * C: Returns the underlying type for for C pointer types or typedefs of
              these types). For example, ``int *`` will return ``int``.
            * C++: Same as in C. Returns an `SBType` representation for data members/
              member functions in case the `SBType` is a pointer to data member or
              pointer to member function.
            * Objective-C: Same as in C. The pointee type of ``id`` and ``Class`` is
              an invalid `SBType`. The pointee type of pointers Objective-C types is an
              `SBType` for the non-pointer type of the respective type. For example,
              ``NSString *`` will return ``NSString`` as a pointee type.

        """
    def GetReferenceType(self):
        """
        GetReferenceType(SBType self) -> SBType
        Returns a type that represents a reference to this type.

            If the type system of the current language can't represent a reference to
            this type, an invalid `SBType` is returned.

            Language-specific behaviour:

            * C: Currently assumes the type system is C++ and returns an l-value
              reference type. For example, ``int`` will return ``int&``. This behavior
              is likely to change in the future and shouldn't be relied on.
            * C++: Same as in C.
            * Objective-C: Same as in C.

        """
    def GetTypedefedType(self):
        """
        GetTypedefedType(SBType self) -> SBType
        Returns the underlying type of a typedef.

            If this type is a typedef as designated by `IsTypedefType`, then the
            underlying type is being returned. Otherwise an invalid `SBType` is
            returned.

            Language-specific behaviour:

            * C: Returns the underlying type of a typedef type.
            * C++: Same as in C. For type aliases, the underlying type is returned.
            * Objective-C: Same as in C.

        """
    def GetDereferencedType(self):
        """
        GetDereferencedType(SBType self) -> SBType
        Returns the underlying type of a reference type.

            If this type is a reference as designated by `IsReferenceType`, then the
            underlying type is being returned. Otherwise an invalid `SBType` is
            returned.

            Language-specific behaviour:

            * C: Always returns an invalid type.
            * C++: For l-value and r-value references the underlying type is returned.
              For example, ``int &`` will return ``int``.
            * Objective-C: Same as in C.

        """
    def GetUnqualifiedType(self):
        """
        GetUnqualifiedType(SBType self) -> SBType
        Returns the unqualified version of this type.

            Language-specific behaviour:

            * C: If this type with any const or volatile specifier removed.
            * C++: Same as in C.
            * Objective-C: Same as in C.

        """
    def GetArrayElementType(self):
        """
        GetArrayElementType(SBType self) -> SBType
        Returns the array element type if this type is an array type.

            Otherwise returns an invalid `SBType` if this type is invalid or not an
            array type.

            Language-specific behaviour:

            * C: If this is an array type (see `IsArrayType`) such as ``T[]``, returns
              the element type.
            * C++: Same as in C.
            * Objective-C: Same as in C.

            See also `IsArrayType`.

        """
    def GetArrayType(self, size):
        """
        GetArrayType(SBType self, uint64_t size) -> SBType
        Returns the array type with the given constant size.

            Language-specific behaviour:

            * C: Returns a constant-size array ``T[size]`` for any non-void type.
            * C++: Same as in C.
            * Objective-C: Same as in C.

            See also `IsArrayType` and `GetArrayElementType`.

        """
    def GetVectorElementType(self):
        """
        GetVectorElementType(SBType self) -> SBType
        Returns the vector element type if this type is a vector type.

            Otherwise returns an invalid `SBType` if this type is invalid or not a
            vector type.

            Language-specific behaviour:

            * C: If this is a vector type (see `IsVectorType`), returns the element
              type.
            * C++: Same as in C.
            * Objective-C: Same as in C.

            See also `IsVectorType`.

        """
    def GetCanonicalType(self):
        """GetCanonicalType(SBType self) -> SBType"""
    def GetEnumerationIntegerType(self):
        """
        GetEnumerationIntegerType(SBType self) -> SBType
        Returns the underlying integer type if this is an enumeration type.

            If this type is an invalid `SBType` or not an enumeration type an invalid
            `SBType` is returned.

            Language-specific behaviour:

            * C: Returns the underlying type for enums.
            * C++: Same as in C but also returns the underlying type for scoped enums.
            * Objective-C: Same as in C.

        """
    def GetBasicType(self, *args):
        """
        GetBasicType(SBType self) -> lldb::BasicType
        GetBasicType(SBType self, lldb::BasicType type) -> SBType
        Returns the `BasicType` value that is most appropriate to this type.

            Returns `eBasicTypeInvalid` if no appropriate `BasicType` was found or this
            type is invalid. See the `BasicType` documentation for the language-specific
            meaning of each `BasicType` value.

            **Overload behaviour:** When called with a `BasicType` parameter, the
            following behaviour applies:

            Returns the `SBType` that represents the passed `BasicType` value. Returns
            an invalid `SBType` if no fitting `SBType` could be created.

            Language-specific behaviour:

            * C: Returns the respective builtin type. Note that some types
              (e.g. ``__uint128_t``) might even be successfully created even if they are
              not available on the target platform. C++ and Objective-C specific types
              might also be created even if the target program is not written in C++ or
              Objective-C.
            * C++: Same as in C.
            * Objective-C: Same as in C.

        """
    def GetNumberOfFields(self):
        """
        GetNumberOfFields(SBType self) -> uint32_t
        Returns the number of fields of this type.

            Returns ``0`` if this type does not have fields.

            Language-specific behaviour:

            * C: Returns the number of fields if the type is a struct. If the type
              contains an anonymous struct/union it only counts as a single field (even
              if the struct/union contains several fields).
            * C++: Returns the number of non-static fields if the type is a
              struct/class. If the type contains an anonymous struct/union it only
              counts as a single field (even if the struct/union contains several
              fields). The fields of any base classes are not included in the count.
            * Objective-C: Same as in C for structs. For Objective-C classes the number
              of ivars is returned.

            See also `GetFieldAtIndex`.

        """
    def GetNumberOfDirectBaseClasses(self):
        """
        GetNumberOfDirectBaseClasses(SBType self) -> uint32_t
        Returns the number of base/parent classes of this type.

            Returns ``0`` if this type doesn't have any base classes.

            Language-specific behaviour:

            * C: Returns always ``0``.
            * C++: The number of direct non-virtual base classes if this type is
              a class.
            * Objective-C: The number of super classes for Objective-C classes.
              As Objective-C doesn't have multiple inheritance this is usually returns 1
              except for NSObject.

        """
    def GetNumberOfVirtualBaseClasses(self):
        """
        GetNumberOfVirtualBaseClasses(SBType self) -> uint32_t
        Returns the number of virtual base/parent classes of this type

            Returns ``0`` if this type doesn't have any base classes.

            Language-specific behaviour:

            * C: Returns always ``0``.
            * C++: The number of direct virtual base classes if this type is a
              class.
            * Objective-C: Returns always ``0``.

        """
    def GetFieldAtIndex(self, idx):
        """
        GetFieldAtIndex(SBType self, uint32_t idx) -> SBTypeMember
        Returns the field at the given index.

            Returns an invalid `SBType` if the index is out of range or the current
            type doesn't have any fields.

            Language-specific behaviour:

            * C: Returns the field with the given index for struct types. Fields are
              ordered/indexed starting from ``0`` for the first field in a struct (as
              declared in the definition).
            * C++: Returns the non-static field with the given index for struct types.
              Fields are ordered/indexed starting from ``0`` for the first field in a
              struct (as declared in the definition).
            * Objective-C: Same as in C for structs. For Objective-C classes the ivar
              with the given index is returned. ivars are indexed starting from ``0``.

        """
    def GetDirectBaseClassAtIndex(self, idx):
        """
        GetDirectBaseClassAtIndex(SBType self, uint32_t idx) -> SBTypeMember
        Returns the direct base class as indexed by `GetNumberOfDirectBaseClasses`.

            Returns an invalid SBTypeMember if the index is invalid or this SBType is
            invalid.

        """
    def GetVirtualBaseClassAtIndex(self, idx):
        """
        GetVirtualBaseClassAtIndex(SBType self, uint32_t idx) -> SBTypeMember
        Returns the virtual base class as indexed by
            `GetNumberOfVirtualBaseClasses`.

            Returns an invalid SBTypeMember if the index is invalid or this SBType is
            invalid.

        """
    def GetEnumMembers(self):
        """GetEnumMembers(SBType self) -> SBTypeEnumMemberList"""
    def GetNumberOfTemplateArguments(self):
        """
        GetNumberOfTemplateArguments(SBType self) -> uint32_t
        Returns the number of template arguments of this type.

            Returns ``0`` if this type is not a template.

            Language-specific behaviour:

            * C: Always returns ``0``.
            * C++: If this type is a class template instantiation then this returns the
              number of template parameters that were used in this instantiation. This
              includes both explicit and implicit template parameters.
            * Objective-C: Always returns ``0``.

        """
    def GetTemplateArgumentType(self, idx):
        """
        GetTemplateArgumentType(SBType self, uint32_t idx) -> SBType
        Returns the type of the template argument with the given index.

            Returns an invalid `SBType` if there is no template argument with the given
            index or this type is not a template. The first template  argument has the
            index ``0``.

            Language-specific behaviour:

            * C: Always returns an invalid SBType.
            * C++: If this type is a class template instantiation and the template
              parameter with the given index is a type template parameter, then this
              returns the type of that parameter. Otherwise returns an invalid `SBType`.
            * Objective-C: Always returns an invalid SBType.

        """
    def GetTemplateArgumentKind(self, idx):
        """
        GetTemplateArgumentKind(SBType self, uint32_t idx) -> lldb::TemplateArgumentKind
        Returns the kind of the template argument with the given index.

            Returns `eTemplateArgumentKindNull` if there is no template argument
            with the given index or this type is not a template. The first template
            argument has the index ``0``.

            Language-specific behaviour:

            * C: Always returns `eTemplateArgumentKindNull`.
            * C++: If this type is a class template instantiation then this returns
              the appropriate `TemplateArgument` value for the parameter with the given
              index. See the documentation of `TemplateArgument` for how certain C++
              template parameter kinds are mapped to `TemplateArgument` values.
            * Objective-C: Always returns `eTemplateArgumentKindNull`.

        """
    def GetFunctionReturnType(self):
        """
        GetFunctionReturnType(SBType self) -> SBType
        Returns the return type if this type represents a function.

            Returns an invalid `SBType` if this type is not a function type or invalid.

            Language-specific behaviour:

            * C: For functions return the return type. Returns an invalid `SBType` if
              this type is a function pointer type.
            * C++: Same as in C for functions and instantiated template functions.
              Member functions are also considered functions. For functions that have
              their return type specified by a placeholder type specifier (``auto``)
              this returns the deduced return type.
            * Objective-C: Same as in C for functions. For Objective-C methods this
              returns the return type of the method.

        """
    def GetFunctionArgumentTypes(self):
        """
        GetFunctionArgumentTypes(SBType self) -> SBTypeList
        Returns the list of argument types if this type represents a function.

            Returns an invalid `SBType` if this type is not a function type or invalid.

            Language-specific behaviour:

            * C: For functions return the types of each parameter. Returns an invalid
              `SBType` if this type is a function pointer. For variadic functions this
              just returns the list of parameters before the variadic arguments.
            * C++: Same as in C for functions and instantiated template functions.
              Member functions are also considered functions.
            * Objective-C: Always returns an invalid SBType for Objective-C methods.

        """
    def GetNumberOfMemberFunctions(self):
        """
        GetNumberOfMemberFunctions(SBType self) -> uint32_t
        Returns the number of member functions of this type.

            Returns ``0`` if an error occurred or this type is invalid.

            Language-specific behaviour:

            * C: Always returns ``0``.
            * C++: If this type represents a struct/class, then the number of
              member functions (static and non-static) is returned. The count includes
              constructors and destructors (both explicit and implicit). Member
              functions of base classes are not included in the count.
            * Objective-C: If this type represents a struct/class, then the
              number of methods is returned. Methods in categories or super classes
              are not counted.

        """
    def GetMemberFunctionAtIndex(self, idx):
        """
        GetMemberFunctionAtIndex(SBType self, uint32_t idx) -> SBTypeMemberFunction
        Returns the member function of this type with the given index.

            Returns an invalid `SBTypeMemberFunction` if the index is invalid or this
            type is invalid.

            Language-specific behaviour:

            * C: Always returns an invalid `SBTypeMemberFunction`.
            * C++: Returns the member function or constructor/destructor with the given
              index.
            * Objective-C: Returns the method with the given index.

            See `GetNumberOfMemberFunctions` for what functions can be queried by this
            function.

        """
    def GetModule(self):
        """
        GetModule(SBType self) -> SBModule
        Returns the `SBModule` this `SBType` belongs to.

            Returns no `SBModule` if this type does not belong to any specific
            `SBModule` or this `SBType` is invalid. An invalid `SBModule` might also
            indicate that once came from an `SBModule` but LLDB could no longer
            determine the original module.

        """
    def GetName(self) -> str:
        """
        GetName() -> string
        Returns the name of this type.

            Returns an empty string if an error occurred or this type is invalid.

            Use this function when trying to match a specific type by name in a script.
            The names returned by this function try to uniquely identify a name but
            conflicts can occur (for example, if a C++ program contains two different
            classes with the same name in different translation units. `GetName` can
            return the same name for both class types.)


            Language-specific behaviour:

            * C: The name of the type. For structs the ``struct`` prefix is omitted.
            * C++: Returns the qualified name of the type (including anonymous/inline
              namespaces and all template arguments).
            * Objective-C: Same as in C.

        """
    def GetDisplayTypeName(self):
        """
        GetDisplayTypeName() -> string
        Returns the name of this type in a user-friendly format.

            Returns an empty string if an error occurred or this type is invalid.

            Use this function when displaying a type name to the user.

            Language-specific behaviour:

            * C: Returns the type name. For structs the ``struct`` prefix is omitted.
            * C++: Returns the qualified name. Anonymous/inline namespaces are omitted.
              Template arguments that match their default value might also be hidden
              (this functionality depends on whether LLDB can determine the template's
              default arguments).
            * Objective-C: Same as in C.

        """
    def GetTypeClass(self):
        """
        GetTypeClass() -> TypeClass
        Returns the `TypeClass` for this type.

            Returns an `eTypeClassInvalid` if this `SBType` is invalid.

            See `TypeClass` for the language-specific meaning of each `TypeClass` value.

        """
    def IsTypeComplete(self):
        """
        IsTypeComplete(SBType self) -> bool
        Returns true if the type is completely defined.

            Language-specific behaviour:

            * C: Returns false for struct types that were only forward declared in the
              type's `SBTarget`/`SBModule`. Otherwise returns true.
            * C++: Returns false for template/non-template struct/class types and
              scoped enums that were only forward declared inside the type's
              `SBTarget`/`SBModule`. Otherwise returns true.
            * Objective-C: Follows the same behavior as C for struct types. Objective-C
              classes are considered complete unless they were only forward declared via
              ``@class ClassName`` in the type's `SBTarget`/`SBModule`. Otherwise
              returns true.

        """
    def GetTypeFlags(self):
        """
        GetTypeFlags(SBType self) -> uint32_t
        Returns the `TypeFlags` values for this type.

            See the respective `TypeFlags` values for what values can be set. Returns an
            integer in which each `TypeFlags` value is represented by a bit. Specific
            flags can be checked via Python's bitwise operators. For example, the
            `eTypeIsInteger` flag can be checked like this:

            ``(an_sb_type.GetTypeFlags() & lldb.eTypeIsInteger) != 0``

            If this type is invalid this returns ``0``.

            See the different values for `TypeFlags` for the language-specific meanings
            of each `TypeFlags` value.

        """
    def GetDescription(self, description, description_level):
        """GetDescription(SBType self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
    def FindDirectNestedType(self, name):
        """
        FindDirectNestedType(SBType self, char const * name) -> SBType
        Searches for a directly nested type that has the provided name.

            Returns the type if it was found.
            Returns invalid type if nothing was found.

        """
    def __eq__(self, rhs):
        """__eq__(SBType self, SBType rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBType self, SBType rhs) -> bool"""
    def template_arg_array(self): ...
    def __eq__(self, other): ...
    def __len__(self) -> int: ...
    module: Incomplete
    name: Incomplete
    size: Incomplete
    is_pointer: Incomplete
    is_reference: Incomplete
    num_fields: Incomplete
    num_bases: Incomplete
    num_vbases: Incomplete
    num_template_args: Incomplete
    template_args: Incomplete
    type: Incomplete
    is_complete: Incomplete
    def get_bases_array(self):
        """An accessor function that returns a list() that contains all direct base classes in a lldb.SBType object."""
    def get_vbases_array(self):
        """An accessor function that returns a list() that contains all fields in a lldb.SBType object."""
    def get_fields_array(self):
        """An accessor function that returns a list() that contains all fields in a lldb.SBType object."""
    def get_members_array(self):
        """An accessor function that returns a list() that contains all members (base classes and fields) in a lldb.SBType object in ascending bit offset order."""
    def get_enum_members_array(self):
        """An accessor function that returns a list() that contains all enum members in an lldb.SBType object."""
    bases: Incomplete
    vbases: Incomplete
    fields: Incomplete
    members: Incomplete
    enum_members: Incomplete

class SBTypeList:
    """
    Represents a list of :py:class:`SBType` s.

    The FindTypes() method of :py:class:`SBTarget`/:py:class:`SBModule` returns a SBTypeList.

    SBTypeList supports :py:class:`SBType` iteration. For example,

    .. code-block:: cpp

        // main.cpp:

        class Task {
        public:
            int id;
            Task *next;
            Task(int i, Task *n):
                id(i),
                next(n)
            {}
        };

    .. code-block:: python

        # find_type.py:

        # Get the type 'Task'.
        type_list = target.FindTypes('Task')
        self.assertTrue(len(type_list) == 1)
        # To illustrate the SBType iteration.
        for type in type_list:
            # do something with type


    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBTypeList self) -> SBTypeList
        __init__(SBTypeList self, SBTypeList rhs) -> SBTypeList
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBTypeList self) -> bool"""
    def Append(self, type):
        """Append(SBTypeList self, SBType type)"""
    def GetTypeAtIndex(self, index):
        """GetTypeAtIndex(SBTypeList self, uint32_t index) -> SBType"""
    def GetSize(self):
        """GetSize(SBTypeList self) -> uint32_t"""
    def __eq__(self, other): ...
    def __iter__(self):
        """Iterate over all types in a lldb.SBTypeList object."""
    def __len__(self) -> int:
        """Return the number of types in a lldb.SBTypeList object."""

class SBTypeCategory:
    """Represents a category that can contain formatters for types."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBTypeCategory self) -> SBTypeCategory
        __init__(SBTypeCategory self, SBTypeCategory rhs) -> SBTypeCategory
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBTypeCategory self) -> bool"""
    def GetEnabled(self):
        """GetEnabled(SBTypeCategory self) -> bool"""
    def SetEnabled(self, arg2):
        """SetEnabled(SBTypeCategory self, bool arg2)"""
    def GetName(self):
        """GetName(SBTypeCategory self) -> char const *"""
    def GetLanguageAtIndex(self, idx):
        """GetLanguageAtIndex(SBTypeCategory self, uint32_t idx) -> lldb::LanguageType"""
    def GetNumLanguages(self):
        """GetNumLanguages(SBTypeCategory self) -> uint32_t"""
    def AddLanguage(self, language):
        """AddLanguage(SBTypeCategory self, lldb::LanguageType language)"""
    def GetDescription(self, description, description_level):
        """GetDescription(SBTypeCategory self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
    def GetNumFormats(self):
        """GetNumFormats(SBTypeCategory self) -> uint32_t"""
    def GetNumSummaries(self):
        """GetNumSummaries(SBTypeCategory self) -> uint32_t"""
    def GetNumFilters(self):
        """GetNumFilters(SBTypeCategory self) -> uint32_t"""
    def GetNumSynthetics(self):
        """GetNumSynthetics(SBTypeCategory self) -> uint32_t"""
    def GetTypeNameSpecifierForFilterAtIndex(self, arg2):
        """GetTypeNameSpecifierForFilterAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeNameSpecifier"""
    def GetTypeNameSpecifierForFormatAtIndex(self, arg2):
        """GetTypeNameSpecifierForFormatAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeNameSpecifier"""
    def GetTypeNameSpecifierForSummaryAtIndex(self, arg2):
        """GetTypeNameSpecifierForSummaryAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeNameSpecifier"""
    def GetTypeNameSpecifierForSyntheticAtIndex(self, arg2):
        """GetTypeNameSpecifierForSyntheticAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeNameSpecifier"""
    def GetFilterForType(self, arg2):
        """GetFilterForType(SBTypeCategory self, SBTypeNameSpecifier arg2) -> SBTypeFilter"""
    def GetFormatForType(self, arg2):
        """GetFormatForType(SBTypeCategory self, SBTypeNameSpecifier arg2) -> SBTypeFormat"""
    def GetSummaryForType(self, arg2):
        """GetSummaryForType(SBTypeCategory self, SBTypeNameSpecifier arg2) -> SBTypeSummary"""
    def GetSyntheticForType(self, arg2):
        """GetSyntheticForType(SBTypeCategory self, SBTypeNameSpecifier arg2) -> SBTypeSynthetic"""
    def GetFilterAtIndex(self, arg2):
        """GetFilterAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeFilter"""
    def GetFormatAtIndex(self, arg2):
        """GetFormatAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeFormat"""
    def GetSummaryAtIndex(self, arg2):
        """GetSummaryAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeSummary"""
    def GetSyntheticAtIndex(self, arg2):
        """GetSyntheticAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeSynthetic"""
    def AddTypeFormat(self, arg2, arg3):
        """AddTypeFormat(SBTypeCategory self, SBTypeNameSpecifier arg2, SBTypeFormat arg3) -> bool"""
    def DeleteTypeFormat(self, arg2):
        """DeleteTypeFormat(SBTypeCategory self, SBTypeNameSpecifier arg2) -> bool"""
    def AddTypeSummary(self, arg2, arg3):
        """AddTypeSummary(SBTypeCategory self, SBTypeNameSpecifier arg2, SBTypeSummary arg3) -> bool"""
    def DeleteTypeSummary(self, arg2):
        """DeleteTypeSummary(SBTypeCategory self, SBTypeNameSpecifier arg2) -> bool"""
    def AddTypeFilter(self, arg2, arg3):
        """AddTypeFilter(SBTypeCategory self, SBTypeNameSpecifier arg2, SBTypeFilter arg3) -> bool"""
    def DeleteTypeFilter(self, arg2):
        """DeleteTypeFilter(SBTypeCategory self, SBTypeNameSpecifier arg2) -> bool"""
    def AddTypeSynthetic(self, arg2, arg3):
        """AddTypeSynthetic(SBTypeCategory self, SBTypeNameSpecifier arg2, SBTypeSynthetic arg3) -> bool"""
    def DeleteTypeSynthetic(self, arg2):
        """DeleteTypeSynthetic(SBTypeCategory self, SBTypeNameSpecifier arg2) -> bool"""
    def __eq__(self, rhs):
        """__eq__(SBTypeCategory self, SBTypeCategory rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBTypeCategory self, SBTypeCategory rhs) -> bool"""
    def __eq__(self, other): ...
    class formatters_access_class:
        """A helper object that will lazily hand out formatters for a specific category."""
        sbcategory: Incomplete
        get_count_function: Incomplete
        get_at_index_function: Incomplete
        get_by_name_function: Incomplete
        regex_type: Incomplete
        def __init__(self, sbcategory, get_count_function, get_at_index_function, get_by_name_function) -> None: ...
        def __len__(self) -> int: ...
        def __getitem__(self, key): ...
    def get_formats_access_object(self):
        """An accessor function that returns an accessor object which allows lazy format access from a lldb.SBTypeCategory object."""
    def get_formats_array(self):
        """An accessor function that returns a list() that contains all formats in a lldb.SBCategory object."""
    def get_summaries_access_object(self):
        """An accessor function that returns an accessor object which allows lazy summary access from a lldb.SBTypeCategory object."""
    def get_summaries_array(self):
        """An accessor function that returns a list() that contains all summaries in a lldb.SBCategory object."""
    def get_synthetics_access_object(self):
        """An accessor function that returns an accessor object which allows lazy synthetic children provider access from a lldb.SBTypeCategory object."""
    def get_synthetics_array(self):
        """An accessor function that returns a list() that contains all synthetic children providers in a lldb.SBCategory object."""
    def get_filters_access_object(self):
        """An accessor function that returns an accessor object which allows lazy filter access from a lldb.SBTypeCategory object."""
    def get_filters_array(self):
        """An accessor function that returns a list() that contains all filters in a lldb.SBCategory object."""
    formats: Incomplete
    format: Incomplete
    summaries: Incomplete
    summary: Incomplete
    filters: Incomplete
    filter: Incomplete
    synthetics: Incomplete
    synthetic: Incomplete
    num_formats: Incomplete
    num_summaries: Incomplete
    num_filters: Incomplete
    num_synthetics: Incomplete
    name: Incomplete
    enabled: Incomplete

class SBTypeEnumMember:
    """Represents a member of an enum in lldb."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBTypeEnumMember self) -> SBTypeEnumMember
        __init__(SBTypeEnumMember self, SBTypeEnumMember rhs) -> SBTypeEnumMember
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBTypeEnumMember self) -> bool"""
    def GetValueAsSigned(self):
        """GetValueAsSigned(SBTypeEnumMember self) -> int64_t"""
    def GetValueAsUnsigned(self):
        """GetValueAsUnsigned(SBTypeEnumMember self) -> uint64_t"""
    def GetName(self):
        """GetName(SBTypeEnumMember self) -> char const *"""
    def GetType(self):
        """GetType(SBTypeEnumMember self) -> SBType"""
    def GetDescription(self, description, description_level):
        """GetDescription(SBTypeEnumMember self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
    def __iter__(self):
        """Iterate over all members in a lldb.SBTypeEnumMemberList object."""
    def __len__(self) -> int:
        """Return the number of members in a lldb.SBTypeEnumMemberList object."""
    name: Incomplete
    type: Incomplete
    signed: Incomplete
    unsigned: Incomplete

class SBTypeEnumMemberList:
    """
    Represents a list of SBTypeEnumMembers.

    SBTypeEnumMemberList supports SBTypeEnumMember iteration.
    It also supports [] access either by index, or by enum
    element name by doing: ::

      myType = target.FindFirstType('MyEnumWithElementA')
      members = myType.GetEnumMembers()
      first_elem = members[0]
      elem_A = members['A']


    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBTypeEnumMemberList self) -> SBTypeEnumMemberList
        __init__(SBTypeEnumMemberList self, SBTypeEnumMemberList rhs) -> SBTypeEnumMemberList
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBTypeEnumMemberList self) -> bool"""
    def Append(self, entry):
        """Append(SBTypeEnumMemberList self, SBTypeEnumMember entry)"""
    def GetTypeEnumMemberAtIndex(self, index):
        """GetTypeEnumMemberAtIndex(SBTypeEnumMemberList self, uint32_t index) -> SBTypeEnumMember"""
    def GetSize(self):
        """GetSize(SBTypeEnumMemberList self) -> uint32_t"""
    def __iter__(self):
        """Iterate over all members in a lldb.SBTypeEnumMemberList object."""
    def __len__(self) -> int:
        """Return the number of members in a lldb.SBTypeEnumMemberList object."""
    def __getitem__(self, key): ...

class SBTypeFilter:
    """Represents a filter that can be associated to one or more types."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBTypeFilter self) -> SBTypeFilter
        __init__(SBTypeFilter self, uint32_t options) -> SBTypeFilter
        __init__(SBTypeFilter self, SBTypeFilter rhs) -> SBTypeFilter
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBTypeFilter self) -> bool"""
    def GetNumberOfExpressionPaths(self):
        """GetNumberOfExpressionPaths(SBTypeFilter self) -> uint32_t"""
    def GetExpressionPathAtIndex(self, i):
        """GetExpressionPathAtIndex(SBTypeFilter self, uint32_t i) -> char const *"""
    def ReplaceExpressionPathAtIndex(self, i, item):
        """ReplaceExpressionPathAtIndex(SBTypeFilter self, uint32_t i, char const * item) -> bool"""
    def AppendExpressionPath(self, item):
        """AppendExpressionPath(SBTypeFilter self, char const * item)"""
    def Clear(self):
        """Clear(SBTypeFilter self)"""
    def GetOptions(self):
        """GetOptions(SBTypeFilter self) -> uint32_t"""
    def SetOptions(self, arg2):
        """SetOptions(SBTypeFilter self, uint32_t arg2)"""
    def GetDescription(self, description, description_level):
        """GetDescription(SBTypeFilter self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
    def IsEqualTo(self, rhs):
        """IsEqualTo(SBTypeFilter self, SBTypeFilter rhs) -> bool"""
    def __eq__(self, rhs):
        """__eq__(SBTypeFilter self, SBTypeFilter rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBTypeFilter self, SBTypeFilter rhs) -> bool"""
    def __eq__(self, other): ...
    options: Incomplete
    count: Incomplete
    def __eq__(self, rhs): ...
    def __ne__(self, rhs): ...

class SBTypeFormat:
    """Represents a format that can be associated to one or more types."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBTypeFormat self) -> SBTypeFormat
        __init__(SBTypeFormat self, lldb::Format format, uint32_t options=0) -> SBTypeFormat
        __init__(SBTypeFormat self, char const * type, uint32_t options=0) -> SBTypeFormat
        __init__(SBTypeFormat self, SBTypeFormat rhs) -> SBTypeFormat
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBTypeFormat self) -> bool"""
    def GetFormat(self):
        """GetFormat(SBTypeFormat self) -> lldb::Format"""
    def GetTypeName(self):
        """GetTypeName(SBTypeFormat self) -> char const *"""
    def GetOptions(self):
        """GetOptions(SBTypeFormat self) -> uint32_t"""
    def SetFormat(self, arg2):
        """SetFormat(SBTypeFormat self, lldb::Format arg2)"""
    def SetTypeName(self, arg2):
        """SetTypeName(SBTypeFormat self, char const * arg2)"""
    def SetOptions(self, arg2):
        """SetOptions(SBTypeFormat self, uint32_t arg2)"""
    def GetDescription(self, description, description_level):
        """GetDescription(SBTypeFormat self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
    def IsEqualTo(self, rhs):
        """IsEqualTo(SBTypeFormat self, SBTypeFormat rhs) -> bool"""
    def __eq__(self, rhs):
        """__eq__(SBTypeFormat self, SBTypeFormat rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBTypeFormat self, SBTypeFormat rhs) -> bool"""
    def __eq__(self, other): ...
    format: Incomplete
    options: Incomplete

class SBTypeNameSpecifier:
    """Represents a general way to provide a type name to LLDB APIs."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBTypeNameSpecifier self) -> SBTypeNameSpecifier
        __init__(SBTypeNameSpecifier self, char const * name, bool is_regex=False) -> SBTypeNameSpecifier
        __init__(SBTypeNameSpecifier self, char const * name, lldb::FormatterMatchType match_type) -> SBTypeNameSpecifier
        __init__(SBTypeNameSpecifier self, SBType type) -> SBTypeNameSpecifier
        __init__(SBTypeNameSpecifier self, SBTypeNameSpecifier rhs) -> SBTypeNameSpecifier
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBTypeNameSpecifier self) -> bool"""
    def GetName(self):
        """GetName(SBTypeNameSpecifier self) -> char const *"""
    def GetType(self):
        """GetType(SBTypeNameSpecifier self) -> SBType"""
    def GetMatchType(self):
        """GetMatchType(SBTypeNameSpecifier self) -> lldb::FormatterMatchType"""
    def IsRegex(self):
        """IsRegex(SBTypeNameSpecifier self) -> bool"""
    def GetDescription(self, description, description_level):
        """GetDescription(SBTypeNameSpecifier self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
    def IsEqualTo(self, rhs):
        """IsEqualTo(SBTypeNameSpecifier self, SBTypeNameSpecifier rhs) -> bool"""
    def __eq__(self, rhs):
        """__eq__(SBTypeNameSpecifier self, SBTypeNameSpecifier rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBTypeNameSpecifier self, SBTypeNameSpecifier rhs) -> bool"""
    def __eq__(self, other): ...
    name: Incomplete
    is_regex: Incomplete
    def __eq__(self, rhs): ...
    def __ne__(self, rhs): ...

class SBTypeSummaryOptions:
    """Proxy of C++ lldb::SBTypeSummaryOptions class."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBTypeSummaryOptions self) -> SBTypeSummaryOptions
        __init__(SBTypeSummaryOptions self, SBTypeSummaryOptions rhs) -> SBTypeSummaryOptions
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBTypeSummaryOptions self) -> bool"""
    def GetLanguage(self):
        """GetLanguage(SBTypeSummaryOptions self) -> lldb::LanguageType"""
    def GetCapping(self):
        """GetCapping(SBTypeSummaryOptions self) -> lldb::TypeSummaryCapping"""
    def SetLanguage(self, arg2):
        """SetLanguage(SBTypeSummaryOptions self, lldb::LanguageType arg2)"""
    def SetCapping(self, arg2):
        """SetCapping(SBTypeSummaryOptions self, lldb::TypeSummaryCapping arg2)"""

class SBTypeSummary:
    """Represents a summary that can be associated to one or more types."""
    thisown: Incomplete
    @staticmethod
    def CreateWithSummaryString(data, options: int = 0):
        """CreateWithSummaryString(char const * data, uint32_t options=0) -> SBTypeSummary"""
    @staticmethod
    def CreateWithFunctionName(data, options: int = 0):
        """CreateWithFunctionName(char const * data, uint32_t options=0) -> SBTypeSummary"""
    @staticmethod
    def CreateWithScriptCode(data, options: int = 0):
        """CreateWithScriptCode(char const * data, uint32_t options=0) -> SBTypeSummary"""
    def __init__(self, *args) -> None:
        """
        __init__(SBTypeSummary self) -> SBTypeSummary
        __init__(SBTypeSummary self, SBTypeSummary rhs) -> SBTypeSummary
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBTypeSummary self) -> bool"""
    def IsFunctionCode(self):
        """IsFunctionCode(SBTypeSummary self) -> bool"""
    def IsFunctionName(self):
        """IsFunctionName(SBTypeSummary self) -> bool"""
    def IsSummaryString(self):
        """IsSummaryString(SBTypeSummary self) -> bool"""
    def GetData(self):
        """GetData(SBTypeSummary self) -> char const *"""
    def SetSummaryString(self, data):
        """SetSummaryString(SBTypeSummary self, char const * data)"""
    def SetFunctionName(self, data):
        """SetFunctionName(SBTypeSummary self, char const * data)"""
    def SetFunctionCode(self, data):
        """SetFunctionCode(SBTypeSummary self, char const * data)"""
    def GetOptions(self):
        """GetOptions(SBTypeSummary self) -> uint32_t"""
    def SetOptions(self, arg2):
        """SetOptions(SBTypeSummary self, uint32_t arg2)"""
    def GetDescription(self, description, description_level):
        """GetDescription(SBTypeSummary self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
    def DoesPrintValue(self, value):
        """DoesPrintValue(SBTypeSummary self, SBValue value) -> bool"""
    def IsEqualTo(self, rhs):
        """IsEqualTo(SBTypeSummary self, SBTypeSummary rhs) -> bool"""
    def __eq__(self, rhs):
        """__eq__(SBTypeSummary self, SBTypeSummary rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBTypeSummary self, SBTypeSummary rhs) -> bool"""
    def __eq__(self, other): ...
    options: Incomplete
    is_summary_string: Incomplete
    is_function_name: Incomplete
    summary_data: Incomplete
    def __eq__(self, rhs): ...
    def __ne__(self, rhs): ...

class SBTypeSynthetic:
    """Represents a summary that can be associated to one or more types."""
    thisown: Incomplete
    @staticmethod
    def CreateWithClassName(data, options: int = 0):
        """CreateWithClassName(char const * data, uint32_t options=0) -> SBTypeSynthetic"""
    @staticmethod
    def CreateWithScriptCode(data, options: int = 0):
        """CreateWithScriptCode(char const * data, uint32_t options=0) -> SBTypeSynthetic"""
    def __init__(self, *args) -> None:
        """
        __init__(SBTypeSynthetic self) -> SBTypeSynthetic
        __init__(SBTypeSynthetic self, SBTypeSynthetic rhs) -> SBTypeSynthetic
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBTypeSynthetic self) -> bool"""
    def IsClassCode(self):
        """IsClassCode(SBTypeSynthetic self) -> bool"""
    def IsClassName(self):
        """IsClassName(SBTypeSynthetic self) -> bool"""
    def GetData(self):
        """GetData(SBTypeSynthetic self) -> char const *"""
    def SetClassName(self, data):
        """SetClassName(SBTypeSynthetic self, char const * data)"""
    def SetClassCode(self, data):
        """SetClassCode(SBTypeSynthetic self, char const * data)"""
    def GetOptions(self):
        """GetOptions(SBTypeSynthetic self) -> uint32_t"""
    def SetOptions(self, arg2):
        """SetOptions(SBTypeSynthetic self, uint32_t arg2)"""
    def GetDescription(self, description, description_level):
        """GetDescription(SBTypeSynthetic self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
    def IsEqualTo(self, rhs):
        """IsEqualTo(SBTypeSynthetic self, SBTypeSynthetic rhs) -> bool"""
    def __eq__(self, rhs):
        """__eq__(SBTypeSynthetic self, SBTypeSynthetic rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBTypeSynthetic self, SBTypeSynthetic rhs) -> bool"""
    def __eq__(self, other): ...
    options: Incomplete
    contains_code: Incomplete
    synthetic_data: Incomplete
    def __eq__(self, rhs): ...
    def __ne__(self, rhs): ...

class SBUnixSignals:
    """Allows you to manipulate LLDB's signal disposition"""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBUnixSignals self) -> SBUnixSignals
        __init__(SBUnixSignals self, SBUnixSignals rhs) -> SBUnixSignals
        """
    __swig_destroy__: Incomplete
    def Clear(self):
        """Clear(SBUnixSignals self)"""
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBUnixSignals self) -> bool"""
    def GetSignalAsCString(self, signo):
        """GetSignalAsCString(SBUnixSignals self, int32_t signo) -> char const *"""
    def GetSignalNumberFromName(self, name):
        """GetSignalNumberFromName(SBUnixSignals self, char const * name) -> int32_t"""
    def GetShouldSuppress(self, signo):
        """GetShouldSuppress(SBUnixSignals self, int32_t signo) -> bool"""
    def SetShouldSuppress(self, signo, value):
        """SetShouldSuppress(SBUnixSignals self, int32_t signo, bool value) -> bool"""
    def GetShouldStop(self, signo):
        """GetShouldStop(SBUnixSignals self, int32_t signo) -> bool"""
    def SetShouldStop(self, signo, value):
        """SetShouldStop(SBUnixSignals self, int32_t signo, bool value) -> bool"""
    def GetShouldNotify(self, signo):
        """GetShouldNotify(SBUnixSignals self, int32_t signo) -> bool"""
    def SetShouldNotify(self, signo, value):
        """SetShouldNotify(SBUnixSignals self, int32_t signo, bool value) -> bool"""
    def GetNumSignals(self):
        """GetNumSignals(SBUnixSignals self) -> int32_t"""
    def GetSignalAtIndex(self, index):
        """GetSignalAtIndex(SBUnixSignals self, int32_t index) -> int32_t"""
    def __iter__(self):
        """Iterate over all signals in a lldb.SBUnixSignals object."""
    def __len__(self) -> int: ...
    def get_unix_signals_list(self): ...
    threads: Incomplete

class SBValue:
    """
    Represents the value of a variable, a register, or an expression.

    SBValue supports iteration through its child, which in turn is represented
    as an SBValue.  For example, we can get the general purpose registers of a
    frame as an SBValue, and iterate through all the registers,::

        registerSet = frame.registers # Returns an SBValueList.
        for regs in registerSet:
            if 'general purpose registers' in regs.name.lower():
                GPRs = regs
                break

        print('%s (number of children = %d):' % (GPRs.name, GPRs.num_children))
        for reg in GPRs:
            print('Name: ', reg.name, ' Value: ', reg.value)

    produces the output: ::

        General Purpose Registers (number of children = 21):
        Name:  rax  Value:  0x0000000100000c5c
        Name:  rbx  Value:  0x0000000000000000
        Name:  rcx  Value:  0x00007fff5fbffec0
        Name:  rdx  Value:  0x00007fff5fbffeb8
        Name:  rdi  Value:  0x0000000000000001
        Name:  rsi  Value:  0x00007fff5fbffea8
        Name:  rbp  Value:  0x00007fff5fbffe80
        Name:  rsp  Value:  0x00007fff5fbffe60
        Name:  r8  Value:  0x0000000008668682
        Name:  r9  Value:  0x0000000000000000
        Name:  r10  Value:  0x0000000000001200
        Name:  r11  Value:  0x0000000000000206
        Name:  r12  Value:  0x0000000000000000
        Name:  r13  Value:  0x0000000000000000
        Name:  r14  Value:  0x0000000000000000
        Name:  r15  Value:  0x0000000000000000
        Name:  rip  Value:  0x0000000100000dae
        Name:  rflags  Value:  0x0000000000000206
        Name:  cs  Value:  0x0000000000000027
        Name:  fs  Value:  0x0000000000000010
        Name:  gs  Value:  0x0000000000000048

    See also linked_list_iter() for another perspective on how to iterate through an
    SBValue instance which interprets the value object as representing the head of a
    linked list.
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBValue self) -> SBValue
        __init__(SBValue self, SBValue rhs) -> SBValue
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBValue self) -> bool"""
    def Clear(self):
        """Clear(SBValue self)"""
    def GetError(self):
        """GetError(SBValue self) -> SBError"""
    def GetID(self):
        """GetID(SBValue self) -> lldb::user_id_t"""
    def GetName(self):
        """GetName(SBValue self) -> char const *"""
    def GetTypeName(self):
        """GetTypeName(SBValue self) -> char const *"""
    def GetDisplayTypeName(self):
        """GetDisplayTypeName(SBValue self) -> char const *"""
    def GetByteSize(self):
        """GetByteSize(SBValue self) -> size_t"""
    def IsInScope(self):
        """IsInScope(SBValue self) -> bool"""
    def GetFormat(self):
        """GetFormat(SBValue self) -> lldb::Format"""
    def SetFormat(self, format):
        """SetFormat(SBValue self, lldb::Format format)"""
    def GetValue(self) -> str:
        """GetValue(SBValue self) -> char const *"""
    def GetValueAsSigned(self, *args):
        """
        GetValueAsSigned(SBValue self, SBError error, int64_t fail_value=0) -> int64_t
        GetValueAsSigned(SBValue self, int64_t fail_value=0) -> int64_t
        """
    def GetValueAsUnsigned(self, *args) -> int:
        """
        GetValueAsUnsigned(SBValue self, SBError error, uint64_t fail_value=0) -> uint64_t
        GetValueAsUnsigned(SBValue self, uint64_t fail_value=0) -> uint64_t
        """
    def GetValueType(self):
        """GetValueType(SBValue self) -> lldb::ValueType"""
    def GetValueDidChange(self):
        """GetValueDidChange(SBValue self) -> bool"""
    def GetSummary(self, *args) -> str:
        """
        GetSummary(SBValue self) -> char const
        GetSummary(SBValue self, SBStream stream, SBTypeSummaryOptions options) -> char const *
        """
    def GetObjectDescription(self):
        """GetObjectDescription(SBValue self) -> char const *"""
    def GetDynamicValue(self, use_dynamic):
        """GetDynamicValue(SBValue self, lldb::DynamicValueType use_dynamic) -> SBValue"""
    def GetStaticValue(self):
        """GetStaticValue(SBValue self) -> SBValue"""
    def GetNonSyntheticValue(self):
        """GetNonSyntheticValue(SBValue self) -> SBValue"""
    def GetPreferDynamicValue(self):
        """GetPreferDynamicValue(SBValue self) -> lldb::DynamicValueType"""
    def SetPreferDynamicValue(self, use_dynamic):
        """SetPreferDynamicValue(SBValue self, lldb::DynamicValueType use_dynamic)"""
    def GetPreferSyntheticValue(self):
        """GetPreferSyntheticValue(SBValue self) -> bool"""
    def SetPreferSyntheticValue(self, use_synthetic):
        """SetPreferSyntheticValue(SBValue self, bool use_synthetic)"""
    def IsDynamic(self):
        """IsDynamic(SBValue self) -> bool"""
    def IsSynthetic(self):
        """IsSynthetic(SBValue self) -> bool"""
    def IsSyntheticChildrenGenerated(self):
        """IsSyntheticChildrenGenerated(SBValue self) -> bool"""
    def SetSyntheticChildrenGenerated(self, arg2):
        """SetSyntheticChildrenGenerated(SBValue self, bool arg2)"""
    def GetLocation(self):
        """GetLocation(SBValue self) -> char const *"""
    def SetValueFromCString(self, *args):
        """
        SetValueFromCString(SBValue self, char const * value_str) -> bool
        SetValueFromCString(SBValue self, char const * value_str, SBError error) -> bool
        """
    def GetTypeFormat(self):
        """GetTypeFormat(SBValue self) -> SBTypeFormat"""
    def GetTypeSummary(self):
        """GetTypeSummary(SBValue self) -> SBTypeSummary"""
    def GetTypeFilter(self):
        """GetTypeFilter(SBValue self) -> SBTypeFilter"""
    def GetTypeSynthetic(self):
        """GetTypeSynthetic(SBValue self) -> SBTypeSynthetic"""
    def CreateChildAtOffset(self, name, offset, type):
        """CreateChildAtOffset(SBValue self, char const * name, uint32_t offset, SBType type) -> SBValue"""
    def Cast(self, type) -> SBValue:
        """Cast(SBValue self, SBType type) -> SBValue"""
    def CreateValueFromExpression(self, *args):
        """
        CreateValueFromExpression(SBValue self, char const * name, char const * expression) -> SBValue
        CreateValueFromExpression(SBValue self, char const * name, char const * expression, SBExpressionOptions options) -> SBValue
        """
    def CreateValueFromAddress(self, name, address, type):
        """CreateValueFromAddress(SBValue self, char const * name, lldb::addr_t address, SBType type) -> SBValue"""
    def CreateValueFromData(self, name, data, type):
        """CreateValueFromData(SBValue self, char const * name, SBData data, SBType type) -> SBValue"""
    def GetChildAtIndex(self, *args):
        """
        GetChildAtIndex(SBValue self, uint32_t idx) -> SBValue
        GetChildAtIndex(SBValue self, uint32_t idx, lldb::DynamicValueType use_dynamic, bool can_create_synthetic) -> SBValue

            Get a child value by index from a value.

            Structs, unions, classes, arrays and pointers have child
            values that can be access by index.

            Structs and unions access child members using a zero based index
            for each child member. For

            Classes reserve the first indexes for base classes that have
            members (empty base classes are omitted), and all members of the
            current class will then follow the base classes.

            Pointers differ depending on what they point to. If the pointer
            points to a simple type, the child at index zero
            is the only child value available, unless synthetic_allowed
            is true, in which case the pointer will be used as an array
            and can create 'synthetic' child values using positive or
            negative indexes. If the pointer points to an aggregate type
            (an array, class, union, struct), then the pointee is
            transparently skipped and any children are going to be the indexes
            of the child values within the aggregate type. For example if
            we have a 'Point' type and we have a SBValue that contains a
            pointer to a 'Point' type, then the child at index zero will be
            the 'x' member, and the child at index 1 will be the 'y' member
            (the child at index zero won't be a 'Point' instance).

            If you actually need an SBValue that represents the type pointed
            to by a SBValue for which GetType().IsPointeeType() returns true,
            regardless of the pointee type, you can do that with the SBValue.Dereference
            method (or the equivalent deref property).

            Arrays have a preset number of children that can be accessed by
            index and will returns invalid child values for indexes that are
            out of bounds unless the synthetic_allowed is true. In this
            case the array can create 'synthetic' child values for indexes
            that aren't in the array bounds using positive or negative
            indexes.

            @param[in] idx
                The index of the child value to get

            @param[in] use_dynamic
                An enumeration that specifies whether to get dynamic values,
                and also if the target can be run to figure out the dynamic
                type of the child value.

            @param[in] synthetic_allowed
                If true, then allow child values to be created by index
                for pointers and arrays for indexes that normally wouldn't
                be allowed.

            @return
                A new SBValue object that represents the child member value.
        """
    def GetIndexOfChildWithName(self, name):
        """
        GetIndexOfChildWithName(SBValue self, char const * name) -> uint32_t

            Returns the child member index.

            Matches children of this object only and will match base classes and
            member names if this is a clang typed object.

            @param[in] name
                The name of the child value to get

            @return
                An index to the child member value.
        """
    def GetChildMemberWithName(self, *args) -> SBValue:
        """
        GetChildMemberWithName(SBValue self, char const * name) -> SBValue
        GetChildMemberWithName(SBValue self, char const * name, lldb::DynamicValueType use_dynamic) -> SBValue

            Returns the child member value.

            Matches child members of this object and child members of any base
            classes.

            @param[in] name
                The name of the child value to get

            @param[in] use_dynamic
                An enumeration that specifies whether to get dynamic values,
                and also if the target can be run to figure out the dynamic
                type of the child value.

            @return
                A new SBValue object that represents the child member value.
        """
    def GetValueForExpressionPath(self, expr_path):
        """
        GetValueForExpressionPath(SBValue self, char const * expr_path) -> SBValue
        Expands nested expressions like .a->b[0].c[1]->d.
        """
    def AddressOf(self):
        """AddressOf(SBValue self) -> SBValue"""
    def GetLoadAddress(self):
        """GetLoadAddress(SBValue self) -> lldb::addr_t"""
    def GetAddress(self) -> SBAddress:
        """GetAddress(SBValue self) -> SBAddress"""
    def GetPointeeData(self, item_idx: int = 0, item_count: int = 1) -> SBData:
        """
        GetPointeeData(SBValue self, uint32_t item_idx=0, uint32_t item_count=1) -> SBData

            Get an SBData wrapping what this SBValue points to.

            This method will dereference the current SBValue, if its
            data type is a ``T\\*`` or ``T[]``, and extract ``item_count`` elements
            of type ``T`` from it, copying their contents in an :py:class:`SBData`.

            :param item_idx: The index of the first item to retrieve. For an array
                this is equivalent to array[item_idx], for a pointer
                to ``\\*(pointer + item_idx)``. In either case, the measurement
                unit for item_idx is the ``sizeof(T)`` rather than the byte
            :param item_count: How many items should be copied into the output. By default
                only one item is copied, but more can be asked for.
            :return: The contents of the copied items on success. An empty :py:class:`SBData` otherwise.
            :rtype: SBData

        """
    def GetData(self):
        """
        GetData(SBValue self) -> SBData

            Get an SBData wrapping the contents of this SBValue.

            This method will read the contents of this object in memory
            and copy them into an SBData for future use.

            @return
                An SBData with the contents of this SBValue, on success.
                An empty SBData otherwise.
        """
    def SetData(self, data, error):
        """SetData(SBValue self, SBData data, SBError error) -> bool"""
    def Clone(self, new_name):
        """Clone(SBValue self, char const * new_name) -> SBValue"""
    def GetDeclaration(self):
        """GetDeclaration(SBValue self) -> SBDeclaration"""
    def MightHaveChildren(self):
        """MightHaveChildren(SBValue self) -> bool"""
    def IsRuntimeSupportValue(self):
        """IsRuntimeSupportValue(SBValue self) -> bool"""
    def GetNumChildren(self, *args):
        """
        GetNumChildren(SBValue self) -> uint32_t
        GetNumChildren(SBValue self, uint32_t max) -> uint32_t
        """
    def GetOpaqueType(self):
        """GetOpaqueType(SBValue self) -> void *"""
    def GetTarget(self):
        """GetTarget(SBValue self) -> SBTarget"""
    def GetProcess(self):
        """GetProcess(SBValue self) -> SBProcess"""
    def GetThread(self):
        """GetThread(SBValue self) -> SBThread"""
    def GetFrame(self):
        """GetFrame(SBValue self) -> SBFrame"""
    def Dereference(self) -> SBValue:
        """Dereference(SBValue self) -> SBValue"""
    def TypeIsPointerType(self) -> bool:
        """TypeIsPointerType(SBValue self) -> bool"""
    def GetType(self) -> SBType:
        """GetType(SBValue self) -> SBType"""
    def Persist(self):
        """Persist(SBValue self) -> SBValue"""
    def GetDescription(self, description):
        """GetDescription(SBValue self, SBStream description) -> bool"""
    def GetExpressionPath(self, *args):
        """
        GetExpressionPath(SBValue self, SBStream description) -> bool
        GetExpressionPath(SBValue self, SBStream description, bool qualify_cxx_base_classes) -> bool
        Returns an expression path for this value.
        """
    def EvaluateExpression(self, *args) -> SBValue:
        """
        EvaluateExpression(SBValue self, char const * expr) -> SBValue
        EvaluateExpression(SBValue self, char const * expr, SBExpressionOptions options) -> SBValue
        EvaluateExpression(SBValue self, char const * expr, SBExpressionOptions options, char const * name) -> SBValue
        """
    def Watch(self, *args):
        """
        Watch(SBValue self, bool resolve_location, bool read, bool write, SBError error) -> SBWatchpoint
        Watch(SBValue self, bool resolve_location, bool read, bool write) -> SBWatchpoint

            Find and watch a variable.
            It returns an SBWatchpoint, which may be invalid.
        """
    def WatchPointee(self, resolve_location, read, write, error):
        """
        WatchPointee(SBValue self, bool resolve_location, bool read, bool write, SBError error) -> SBWatchpoint

            Find and watch the location pointed to by a variable.
            It returns an SBWatchpoint, which may be invalid.
        """
    def GetVTable(self):
        """GetVTable(SBValue self) -> SBValue"""
    def __get_dynamic__(self):
        '''Helper function for the "SBValue.dynamic" property.'''
    class children_access:
        """A helper object that will lazily hand out thread for a process when supplied an index."""
        sbvalue: Incomplete
        def __init__(self, sbvalue) -> None: ...
        def __len__(self) -> int: ...
        def __getitem__(self, key): ...
    def get_child_access_object(self):
        """An accessor function that returns a children_access() object which allows lazy member variable access from a lldb.SBValue object."""
    def get_value_child_list(self):
        """An accessor function that returns a list() that contains all children in a lldb.SBValue object."""
    def __hex__(self): ...
    def __iter__(self):
        """Iterate over all child values of a lldb.SBValue object."""
    def __len__(self) -> int:
        """Return the number of child values of a lldb.SBValue object."""
    children: Incomplete
    child: Incomplete
    name: Incomplete
    type: Incomplete
    size: Incomplete
    is_in_scope: Incomplete
    format: Incomplete
    value: Incomplete
    value_type: Incomplete
    changed: Incomplete
    data: Incomplete
    load_addr: Incomplete
    addr: Incomplete
    deref: Incomplete
    address_of: Incomplete
    error: Incomplete
    summary: Incomplete
    description: Incomplete
    dynamic: Incomplete
    location: Incomplete
    target: Incomplete
    process: Incomplete
    thread: Incomplete
    frame: Incomplete
    num_children: Incomplete
    unsigned: Incomplete
    signed: Incomplete
    def get_expr_path(self): ...
    path: Incomplete
    def synthetic_child_from_expression(self, name, expr, options: Incomplete | None = None): ...
    def synthetic_child_from_data(self, name, data, type): ...
    def synthetic_child_from_address(self, name, addr, type): ...
    def linked_list_iter(self, next_item_name, end_of_list_test=...) -> Generator[Incomplete]:
        """Generator adaptor to support iteration for SBValue as a linked list.

        linked_list_iter() is a special purpose iterator to treat the SBValue as
        the head of a list data structure, where you specify the child member
        name which points to the next item on the list and you specify the
        end-of-list test function which takes an SBValue for an item and returns
        True if EOL is reached and False if not.

        linked_list_iter() also detects infinite loop and bails out early.

        The end_of_list_test arg, if omitted, defaults to the __eol_test
        function above.

        For example,

    # Get Frame #0.
        ...

    # Get variable 'task_head'.
        task_head = frame0.FindVariable('task_head')
        ...

        for t in task_head.linked_list_iter('next'):
            print t
        """

class SBValueList:
    """
    Represents a collection of SBValues.  Both :py:class:`SBFrame.GetVariables()` and
    :py:class:`SBFrame.GetRegisters()` return a SBValueList.

    SBValueList supports :py:class:`SBValue` iteration. For example (from test/lldbutil.py),::

        def get_registers(frame, kind):
            '''Returns the registers given the frame and the kind of registers desired.

            Returns None if there's no such kind.
            '''
            registerSet = frame.GetRegisters() # Return type of SBValueList.
            for value in registerSet:
                if kind.lower() in value.GetName().lower():
                    return value

            return None

        def get_GPRs(frame):
            '''Returns the general purpose registers of the frame as an SBValue.

            The returned SBValue object is iterable.  An example:
                ...
                from lldbutil import get_GPRs
                regs = get_GPRs(frame)
                for reg in regs:
                    print('%s => %s' % (reg.GetName(), reg.GetValue()))
                ...
            '''
            return get_registers(frame, 'general purpose')

        def get_FPRs(frame):
            '''Returns the floating point registers of the frame as an SBValue.

            The returned SBValue object is iterable.  An example:
                ...
                from lldbutil import get_FPRs
                regs = get_FPRs(frame)
                for reg in regs:
                    print('%s => %s' % (reg.GetName(), reg.GetValue()))
                ...
            '''
            return get_registers(frame, 'floating point')

        def get_ESRs(frame):
            '''Returns the exception state registers of the frame as an SBValue.

            The returned SBValue object is iterable.  An example:
                ...
                from lldbutil import get_ESRs
                regs = get_ESRs(frame)
                for reg in regs:
                    print('%s => %s' % (reg.GetName(), reg.GetValue()))
                ...
            '''
            return get_registers(frame, 'exception state')

    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBValueList self) -> SBValueList
        __init__(SBValueList self, SBValueList rhs) -> SBValueList
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBValueList self) -> bool"""
    def Clear(self):
        """Clear(SBValueList self)"""
    def Append(self, *args):
        """
        Append(SBValueList self, SBValue val_obj)
        Append(SBValueList self, SBValueList value_list)
        """
    def GetSize(self):
        """GetSize(SBValueList self) -> uint32_t"""
    def GetValueAtIndex(self, idx):
        """GetValueAtIndex(SBValueList self, uint32_t idx) -> SBValue"""
    def GetFirstValueByName(self, name):
        """GetFirstValueByName(SBValueList self, char const * name) -> SBValue"""
    def FindValueObjectByUID(self, uid):
        """FindValueObjectByUID(SBValueList self, lldb::user_id_t uid) -> SBValue"""
    def GetError(self):
        """GetError(SBValueList self) -> SBError"""
    def __iter__(self):
        """Iterate over all values in a lldb.SBValueList object."""
    def __len__(self) -> int: ...
    def __getitem__(self, key): ...

class SBVariablesOptions:
    """Describes which variables should be returned from :py:class:`SBFrame.GetVariables`."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBVariablesOptions self) -> SBVariablesOptions
        __init__(SBVariablesOptions self, SBVariablesOptions options) -> SBVariablesOptions
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def IsValid(self):
        """IsValid(SBVariablesOptions self) -> bool"""
    def GetIncludeArguments(self):
        """GetIncludeArguments(SBVariablesOptions self) -> bool"""
    def SetIncludeArguments(self, arg2):
        """SetIncludeArguments(SBVariablesOptions self, bool arg2)"""
    def GetIncludeRecognizedArguments(self, arg2):
        """GetIncludeRecognizedArguments(SBVariablesOptions self, SBTarget arg2) -> bool"""
    def SetIncludeRecognizedArguments(self, arg2):
        """SetIncludeRecognizedArguments(SBVariablesOptions self, bool arg2)"""
    def GetIncludeLocals(self):
        """GetIncludeLocals(SBVariablesOptions self) -> bool"""
    def SetIncludeLocals(self, arg2):
        """SetIncludeLocals(SBVariablesOptions self, bool arg2)"""
    def GetIncludeStatics(self):
        """GetIncludeStatics(SBVariablesOptions self) -> bool"""
    def SetIncludeStatics(self, arg2):
        """SetIncludeStatics(SBVariablesOptions self, bool arg2)"""
    def GetInScopeOnly(self):
        """GetInScopeOnly(SBVariablesOptions self) -> bool"""
    def SetInScopeOnly(self, arg2):
        """SetInScopeOnly(SBVariablesOptions self, bool arg2)"""
    def GetIncludeRuntimeSupportValues(self):
        """GetIncludeRuntimeSupportValues(SBVariablesOptions self) -> bool"""
    def SetIncludeRuntimeSupportValues(self, arg2):
        """SetIncludeRuntimeSupportValues(SBVariablesOptions self, bool arg2)"""
    def GetUseDynamic(self):
        """GetUseDynamic(SBVariablesOptions self) -> lldb::DynamicValueType"""
    def SetUseDynamic(self, arg2):
        """SetUseDynamic(SBVariablesOptions self, lldb::DynamicValueType arg2)"""

class SBWatchpoint:
    """
    Represents an instance of watchpoint for a specific target program.

    A watchpoint is determined by the address and the byte size that resulted in
    this particular instantiation.  Each watchpoint has its settable options.

    See also :py:class:`SBTarget.watchpoint_iter()` for example usage of iterating through the
    watchpoints of the target.
    """
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBWatchpoint self) -> SBWatchpoint
        __init__(SBWatchpoint self, SBWatchpoint rhs) -> SBWatchpoint
        """
    __swig_destroy__: Incomplete
    def __nonzero__(self): ...
    __bool__ = __nonzero__
    def __eq__(self, rhs):
        """__eq__(SBWatchpoint self, SBWatchpoint rhs) -> bool"""
    def __ne__(self, rhs):
        """__ne__(SBWatchpoint self, SBWatchpoint rhs) -> bool"""
    def IsValid(self):
        """IsValid(SBWatchpoint self) -> bool"""
    def GetError(self):
        """GetError(SBWatchpoint self) -> SBError"""
    def GetID(self):
        """GetID(SBWatchpoint self) -> lldb::watch_id_t"""
    def GetHardwareIndex(self):
        """
        GetHardwareIndex(SBWatchpoint self) -> int32_t

            Deprecated.  Previously: Return the hardware index of the 
            watchpoint register.  Now: -1 is always returned.
        """
    def GetWatchAddress(self):
        """GetWatchAddress(SBWatchpoint self) -> lldb::addr_t"""
    def GetWatchSize(self):
        """GetWatchSize(SBWatchpoint self) -> size_t"""
    def SetEnabled(self, enabled):
        """SetEnabled(SBWatchpoint self, bool enabled)"""
    def IsEnabled(self):
        """IsEnabled(SBWatchpoint self) -> bool"""
    def GetHitCount(self):
        """GetHitCount(SBWatchpoint self) -> uint32_t"""
    def GetIgnoreCount(self):
        """GetIgnoreCount(SBWatchpoint self) -> uint32_t"""
    def SetIgnoreCount(self, n):
        """SetIgnoreCount(SBWatchpoint self, uint32_t n)"""
    def GetCondition(self):
        """
        GetCondition(SBWatchpoint self) -> char const *

            Get the condition expression for the watchpoint.
        """
    def SetCondition(self, condition):
        """
        SetCondition(SBWatchpoint self, char const * condition)

            The watchpoint stops only if the condition expression evaluates to true.
        """
    def GetDescription(self, description, level):
        """GetDescription(SBWatchpoint self, SBStream description, lldb::DescriptionLevel level) -> bool"""
    def Clear(self):
        """Clear(SBWatchpoint self)"""
    @staticmethod
    def EventIsWatchpointEvent(event):
        """EventIsWatchpointEvent(SBEvent event) -> bool"""
    @staticmethod
    def GetWatchpointEventTypeFromEvent(event):
        """GetWatchpointEventTypeFromEvent(SBEvent event) -> lldb::WatchpointEventType"""
    @staticmethod
    def GetWatchpointFromEvent(event):
        """GetWatchpointFromEvent(SBEvent event) -> SBWatchpoint"""
    def GetType(self):
        """
        GetType(SBWatchpoint self) -> SBType

            Returns the type recorded when the watchpoint was created. For variable
            watchpoints it is the type of the watched variable. For expression
            watchpoints it is the type of the provided expression.
        """
    def GetWatchValueKind(self):
        """
        GetWatchValueKind(SBWatchpoint self) -> lldb::WatchpointValueKind

            Returns the kind of value that was watched when the watchpoint was created.
            Returns one of the following eWatchPointValueKindVariable,
            eWatchPointValueKindExpression, eWatchPointValueKindInvalid.

        """
    def GetWatchSpec(self):
        """
        GetWatchSpec(SBWatchpoint self) -> char const *

            Get the spec for the watchpoint. For variable watchpoints this is the name
            of the variable. For expression watchpoints it is empty
            (may change in the future).
        """
    def IsWatchingReads(self):
        """
        IsWatchingReads(SBWatchpoint self) -> bool

            Returns true if the watchpoint is watching reads. Returns false otherwise.
        """
    def IsWatchingWrites(self):
        """
        IsWatchingWrites(SBWatchpoint self) -> bool

            Returns true if the watchpoint is watching writes. Returns false otherwise.
        """
    def __eq__(self, other): ...
    def __hex__(self): ...
    def __len__(self) -> int: ...

class SBWatchpointOptions:
    """A container for options to use when creating watchpoints."""
    thisown: Incomplete
    def __init__(self, *args) -> None:
        """
        __init__(SBWatchpointOptions self) -> SBWatchpointOptions
        __init__(SBWatchpointOptions self, SBWatchpointOptions rhs) -> SBWatchpointOptions
        """
    __swig_destroy__: Incomplete
    def SetWatchpointTypeRead(self, read):
        """
        SetWatchpointTypeRead(SBWatchpointOptions self, bool read)
        Sets whether the watchpoint should stop on read accesses.
        """
    def GetWatchpointTypeRead(self):
        """
        GetWatchpointTypeRead(SBWatchpointOptions self) -> bool
        Gets whether the watchpoint should stop on read accesses.
        """
    def SetWatchpointTypeWrite(self, write_type):
        """
        SetWatchpointTypeWrite(SBWatchpointOptions self, lldb::WatchpointWriteType write_type)
        Sets whether the watchpoint should stop on write accesses. eWatchpointWriteTypeOnModify is the most commonly useful mode, where lldb will stop when the watched value has changed. eWatchpointWriteTypeAlways will stop on any write to the watched region, even if it's the value is the same.
        """
    def GetWatchpointTypeWrite(self):
        """
        GetWatchpointTypeWrite(SBWatchpointOptions self) -> lldb::WatchpointWriteType
        Gets whether the watchpoint should stop on write accesses, returning WatchpointWriteType to indicate the type of write watching that is enabled, or eWatchpointWriteTypeDisabled.
        """

def in_range(symbol, section):
    """Test whether a symbol is within the range of a section."""
def command(command_name: Incomplete | None = None, doc: Incomplete | None = None): ...

class declaration:
    """A class that represents a source declaration location with file, line and column."""
    file: Incomplete
    line: Incomplete
    col: Incomplete
    def __init__(self, file, line, col) -> None: ...

class value_iter:
    """Allows iterating over the children of an :py:class:`SBValue`."""
    def __iter__(self): ...
    def __next__(self): ...
    def next(self): ...
    def __eq__(self, other): ...
    def __len__(self) -> int: ...
    index: int
    length: int
    sbvalue: Incomplete
    def __init__(self, value) -> None: ...

class value:
    '''Wraps :py:class:`SBValue` objects so the resulting object can be used as a variable would be in code.

    So if you have a Point structure variable in your code in the current frame named "pt",
    you can initialize an instance of this class with it: ::

        pt = lldb.value(lldb.frame.FindVariable("pt"))
        print pt
        print pt.x
        print pt.y

        pt = lldb.value(lldb.frame.FindVariable("rectangle_array"))
        print rectangle_array[12]
        print rectangle_array[5].origin.x'''
    sbvalue: Incomplete
    def __init__(self, sbvalue) -> None: ...
    def __nonzero__(self): ...
    def __bool__(self) -> bool: ...
    def __getitem__(self, key): ...
    def __iter__(self): ...
    def __getattr__(self, name): ...
    def __add__(self, other): ...
    def __sub__(self, other): ...
    def __mul__(self, other): ...
    def __floordiv__(self, other): ...
    def __mod__(self, other): ...
    def __divmod__(self, other): ...
    def __pow__(self, other): ...
    def __lshift__(self, other): ...
    def __rshift__(self, other): ...
    def __and__(self, other): ...
    def __xor__(self, other): ...
    def __or__(self, other): ...
    def __div__(self, other): ...
    def __truediv__(self, other): ...
    def __iadd__(self, other): ...
    def __isub__(self, other): ...
    def __imul__(self, other): ...
    def __idiv__(self, other): ...
    def __itruediv__(self, other): ...
    def __ifloordiv__(self, other): ...
    def __imod__(self, other): ...
    def __ipow__(self, other): ...
    def __ipow__(self, other, modulo): ...
    def __ilshift__(self, other): ...
    def __irshift__(self, other): ...
    def __iand__(self, other): ...
    def __ixor__(self, other): ...
    def __ior__(self, other): ...
    def __neg__(self): ...
    def __pos__(self): ...
    def __abs__(self): ...
    def __invert__(self): ...
    def __complex__(self) -> complex: ...
    def __int__(self) -> int: ...
    def __long__(self): ...
    def __float__(self) -> float: ...
    def __oct__(self): ...
    def __hex__(self): ...
    def __len__(self) -> int: ...
    def __eq__(self, other): ...
    def __ne__(self, other): ...

class SBSyntheticValueProvider:
    def __init__(self, valobj) -> None: ...
    def num_children(self): ...
    def get_child_index(self, name) -> None: ...
    def get_child_at_index(self, idx) -> None: ...
    def update(self) -> None: ...
    def has_children(self): ...
    def __len__(self) -> int: ...
    def __iter__(self):
        """Iterate over all children in a lldb.SBSyntheticValueProvider object."""

def is_numeric_type(basic_type): ...

debugger_unique_id: int
debugger: Incomplete
target: Incomplete
process: Incomplete
thread: Incomplete
frame: Incomplete
